package net.Zrips.CMILib.Items;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.regex.Pattern;

import org.bukkit.Bukkit;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.Skull;
import org.bukkit.inventory.ItemStack;

import net.Zrips.CMILib.CMILib;
import net.Zrips.CMILib.Container.CMIText;
import net.Zrips.CMILib.Logs.CMIDebug;
import net.Zrips.CMILib.Version.Version;

public enum CMIMaterial {
    NONE(),
    ACACIA_BOAT(447, "BOAT_ACACIA", CMIMC.BOAT),
    ACACIA_BUTTON(CMIMC.BUTTON),
    ACACIA_DOOR(430, "ACACIA_DOOR_ITEM", CMIMC.DOOR),
    ACACIA_FENCE(192, CMIMC.SEETHROW, CMIMC.FENCE),
    ACACIA_FENCE_GATE(187, CMIMC.SEETHROW, CMIMC.FENCEGATE),
    ACACIA_LEAVES(161, "LEAVES_2"),
    ACACIA_LOG(162, "LOG_2"),
    ACACIA_PLANKS(5, 4, "Acacia Planks"),
    ACACIA_PRESSURE_PLATE(CMIMC.PRESSUREPLATE),
    ACACIA_SAPLING(6, 4, CMIMC.SAPLING),
    ACACIA_SLAB(126, 4, "Acacia Wood Slab", CMIMC.SLAB),
    ACACIA_STAIRS(163, CMIMC.STAIRS),
    ACACIA_TRAPDOOR(CMIMC.TRAPDOOR),
    ACACIA_WOOD(),
    ACTIVATOR_RAIL(157, CMIMC.RAIL),
    AIR(0, 0, CMIMC.AIR),
    ALLIUM(38, 2, "RED_ROSE", CMIMC.SEETHROW),
    ANDESITE(1, 5),
    ANVIL(145, CMIMC.ANVIL),
    APPLE(260),
    ARMOR_STAND(416),
    ARROW(262),
    ATTACHED_MELON_STEM(),
    ATTACHED_PUMPKIN_STEM(),
    AZURE_BLUET(38, 3),
    BAKED_POTATO(393),
    BARRIER(166),
    BAT_SPAWN_EGG(383, 65, "Spawn Bat", CMIMC.SPAWNEGG),
    BEACON(138),
    BEDROCK(7),
    BEEF(363, "Raw Beef"),
    BEETROOT(434),
    BEETROOTS(207, "BEETROOT_BLOCK"),
    BEETROOT_SEEDS(435),
    BEETROOT_SOUP(436),
    BIRCH_BOAT(445, "BOAT_BIRCH", CMIMC.BOAT),
    BIRCH_BUTTON(CMIMC.BUTTON),
    BIRCH_DOOR(428, "BIRCH_DOOR_ITEM", CMIMC.DOOR),
    BIRCH_FENCE(189, CMIMC.SEETHROW, CMIMC.FENCE),
    BIRCH_FENCE_GATE(184, CMIMC.SEETHROW, CMIMC.FENCEGATE),
    BIRCH_LEAVES(18, 2, "LEAVES"),
    BIRCH_LOG(17, 2, "LOG"),
    BIRCH_PLANKS(5, 2, "Birch Wood Plank"),
    BIRCH_PRESSURE_PLATE(CMIMC.PRESSUREPLATE),
    BIRCH_SAPLING(6, 2, CMIMC.SAPLING),
    BIRCH_SLAB(126, 2, CMIMC.SLAB),
    BIRCH_STAIRS(135, "Birch Wood Stairs", CMIMC.STAIRS),
    BIRCH_TRAPDOOR(CMIMC.TRAPDOOR),
    BIRCH_WOOD(),
    BLACK_BANNER(425),
    BLACK_BED(355, 15, CMIMC.BED),
    BLACK_CARPET(171, 15, "CARPET", CMIMC.CARPET),
    BLACK_CONCRETE(251, 15, "CONCRETE"),
    BLACK_CONCRETE_POWDER(252, 15, "CONCRETE_POWDER"),
    BLACK_GLAZED_TERRACOTTA(250),
    BLACK_SHULKER_BOX(234, CMIMC.SHULKERBOX),
    BLACK_STAINED_GLASS(95, 15, "STAINED_GLASS", CMIMC.SEETHROW),
    BLACK_STAINED_GLASS_PANE(160, 15, "STAINED_GLASS_PANE", CMIMC.SEETHROW, CMIMC.GLASSPANE),
    BLACK_TERRACOTTA(159, 15, "STAINED_CLAY"),
    BLACK_WALL_BANNER(177),
    BLACK_WOOL(35, 15, CMIMC.WOOL),
    BLAZE_POWDER(377),
    BLAZE_ROD(369),
    BLAZE_SPAWN_EGG(383, 61, "Spawn Blaze", CMIMC.SPAWNEGG),
    BLUE_BANNER(245, 4),
    BLUE_BED(355, 11, CMIMC.BED),
    BLUE_CARPET(171, 11, CMIMC.CARPET),
    BLUE_CONCRETE(251, 11),
    BLUE_CONCRETE_POWDER(252, 11),
    BLUE_GLAZED_TERRACOTTA(246),
    BLUE_ICE(),
    BLUE_ORCHID(38, 1),
    BLUE_SHULKER_BOX(230, CMIMC.SHULKERBOX),
    BLUE_STAINED_GLASS(95, 11, CMIMC.SEETHROW),
    BLUE_STAINED_GLASS_PANE(160, 11, CMIMC.SEETHROW, CMIMC.GLASSPANE),
    BLUE_TERRACOTTA(159, 11),
    BLUE_WALL_BANNER(177, 4),
    BLUE_WOOL(35, 11, CMIMC.WOOL),
    BONE(352),
    BONE_BLOCK(216),
    BONE_MEAL(351, 15, CMIMC.DYE),
    BOOK(340),
    BOOKSHELF(47),
    BOW(261, CMIMC.WEAPON),
    BOWL(281),
    BRAIN_CORAL(),
    BRAIN_CORAL_BLOCK(),
    BRAIN_CORAL_FAN(),
    BRAIN_CORAL_WALL_FAN(),
    BREAD(297),
    BREWING_STAND(379, "BREWING_STAND_ITEM"),
    BRICK(336, "claybrick"),
    BRICKS(45),
    BRICK_SLAB(44, 4, "STEP", CMIMC.SLAB),
    BRICK_STAIRS(108, CMIMC.STAIRS),
    BROWN_BANNER(425, 3),
    BROWN_BED(355, 12, CMIMC.BED),
    BROWN_CARPET(171, 12, CMIMC.CARPET),
    BROWN_CONCRETE(251, 12),
    BROWN_CONCRETE_POWDER(252, 12),
    BROWN_GLAZED_TERRACOTTA(247),
    BROWN_MUSHROOM(39),
    BROWN_MUSHROOM_BLOCK(99, "HUGE_MUSHROOM_1"),
    BROWN_SHULKER_BOX(231, CMIMC.SHULKERBOX),
    BROWN_STAINED_GLASS(95, 12, CMIMC.SEETHROW),
    BROWN_STAINED_GLASS_PANE(160, 12, CMIMC.SEETHROW, CMIMC.GLASSPANE),
    BROWN_TERRACOTTA(159, 12),
    BROWN_WALL_BANNER(177, 3),
    BROWN_WOOL(35, 12, CMIMC.WOOL),
    BUBBLE_COLUMN(),
    BUBBLE_CORAL(),
    BUBBLE_CORAL_BLOCK(),
    BUBBLE_CORAL_FAN(),
    BUBBLE_CORAL_WALL_FAN(),
    BUCKET(325, CMIMC.TOOL),
    CACTUS(81),
    CACTUS_GREEN(351, 2, CMIMC.DYE),
    CAKE(354, CMIMC.CAKE),
    CARROT(141),
    CARROTS(391, "Carrotitem"),
    CARROT_ON_A_STICK(398, "carrotstick"),
    CARVED_PUMPKIN(),
    CAULDRON(380, "CAULDRON_ITEM"),
    CAVE_AIR(CMIMC.AIR),
    CAVE_SPIDER_SPAWN_EGG(383, 59, "Spawn Cave Spider", CMIMC.SPAWNEGG),
    CHAINMAIL_BOOTS(305, CMIMC.ARMOR, CMIMC.BOOTS),
    CHAINMAIL_CHESTPLATE(303, CMIMC.ARMOR, CMIMC.CHESTPLATE),
    CHAINMAIL_HELMET(302, CMIMC.ARMOR, CMIMC.HELMET),
    CHAINMAIL_LEGGINGS(304, CMIMC.ARMOR, CMIMC.LEGGINGS),
    CHAIN_COMMAND_BLOCK(),
    CHARCOAL(263, 1),
    CHEST(54),
    CHEST_MINECART(342, "Minecart With Chest"),
    CHICKEN(365, "Raw Chicken"),
    CHICKEN_SPAWN_EGG(383, 93, "Spawn Chicken", CMIMC.SPAWNEGG),
    CHIPPED_ANVIL(145, 1, CMIMC.ANVIL),
    CHISELED_QUARTZ_BLOCK(155, 1),
    CHISELED_RED_SANDSTONE(179, 1),
    CHISELED_SANDSTONE(24, 1),
    CHISELED_STONE_BRICKS(98, 3, "SMOOTH_BRICK"),
    CHORUS_FLOWER(200),
    CHORUS_FRUIT(432),
    CHORUS_PLANT(199),
    CLAY(82, "Clay Block"),
    CLAY_BALL(337),
    CLOCK(347, "watch"),
    COAL(263),
    COAL_BLOCK(173, "Block of Coal"),
    COAL_ORE(16),
    COARSE_DIRT(3, 1),
    COBBLESTONE(4),
    COBBLESTONE_SLAB(44, 3, CMIMC.SLAB),
    COBBLESTONE_STAIRS(67, CMIMC.STAIRS),
    COBBLESTONE_WALL(139, "COBBLE_WALL", CMIMC.WALL),
    COBWEB(30, "WEB", CMIMC.SEETHROW),
    COCOA(127),
    COCOA_BEANS(351, 3, CMIMC.DYE),
    COD("Raw Cod"),
    COD_BUCKET(28601, "Bucket of Cod", CMIMC.BUCKETANIMAL),
    COD_SPAWN_EGG(CMIMC.SPAWNEGG),
    COMMAND_BLOCK(137, "COMMAND"),
    COMMAND_BLOCK_MINECART(422, "Minecart With Command Block"),
    COMPARATOR(404, "Redstone Comparator"),
    COMPASS(345),
    CONDUIT(5148),
    COOKED_BEEF(364, "Steak"),
    COOKED_CHICKEN(366),
    COOKED_COD(350, "Cooked Fish"),
    COOKED_MUTTON(424),
    COOKED_PORKCHOP(320, "grilledpork"),
    COOKED_RABBIT(412),
    COOKED_SALMON(350, 1),
    COOKIE(357),
    COW_SPAWN_EGG(383, 92, "Spawn Cow", CMIMC.SPAWNEGG),
    CRACKED_STONE_BRICKS(98, 2),
    CRAFTING_TABLE(58, "Crafting Table", "WORKBENCH"),
    CREEPER_HEAD(397, 4, "Mob Head (Creeper)", CMIMC.MONSTERHEAD),
    CREEPER_SPAWN_EGG(383, 50, "Spawn Creeper", CMIMC.SPAWNEGG),
    CREEPER_WALL_HEAD(144, 4, CMIMC.MONSTERHEAD),
    CUT_RED_SANDSTONE(),
    CUT_SANDSTONE(),
    CYAN_BANNER(425, 6),
    CYAN_BED(355, 9, CMIMC.BED),
    CYAN_CARPET(171, 9, CMIMC.CARPET),
    CYAN_CONCRETE(251, 9),
    CYAN_CONCRETE_POWDER(252, 9, "Cyan Concrete Powder"),
    CYAN_DYE(351, 6, CMIMC.DYE),
    CYAN_GLAZED_TERRACOTTA(244),
    CYAN_SHULKER_BOX(228, CMIMC.SHULKERBOX),
    CYAN_STAINED_GLASS(95, 9, CMIMC.SEETHROW),
    CYAN_STAINED_GLASS_PANE(160, 9, CMIMC.SEETHROW, CMIMC.GLASSPANE),
    CYAN_TERRACOTTA(159, 9),
    CYAN_WALL_BANNER(177, 6),
    CYAN_WOOL(35, 9, CMIMC.WOOL),
    DAMAGED_ANVIL(145, 2, CMIMC.ANVIL),
    DANDELION(37, "YELLOW_FLOWER"),
    DANDELION_YELLOW(351, 11, CMIMC.DYE),
    DARK_OAK_BOAT(448, "BOAT_DARK_OAK", CMIMC.BOAT),
    DARK_OAK_BUTTON(CMIMC.BUTTON),
    DARK_OAK_DOOR(431, "DARK_OAK_DOOR_ITEM", CMIMC.DOOR),
    DARK_OAK_FENCE(191, CMIMC.SEETHROW, CMIMC.FENCE),
    DARK_OAK_FENCE_GATE(186, CMIMC.SEETHROW, CMIMC.FENCEGATE),
    DARK_OAK_LEAVES(161, 1),
    DARK_OAK_LOG(162, 1),
    DARK_OAK_PLANKS(5, 5, "Dark Oak Wood Plank"),
    DARK_OAK_PRESSURE_PLATE(CMIMC.PRESSUREPLATE),
    DARK_OAK_SAPLING(6, 5, CMIMC.SAPLING),
    DARK_OAK_SLAB(126, 5, "Dark Oak Wood Slab", CMIMC.SLAB),
    DARK_OAK_STAIRS(164, CMIMC.STAIRS),
    DARK_OAK_TRAPDOOR(CMIMC.TRAPDOOR),
    DARK_OAK_WOOD(),
    DARK_PRISMARINE(168, 2),
    DARK_PRISMARINE_SLAB(CMIMC.SLAB),
    DARK_PRISMARINE_STAIRS(CMIMC.STAIRS),
    DAYLIGHT_DETECTOR(151),
    DEAD_BRAIN_CORAL(),
    DEAD_BRAIN_CORAL_BLOCK(),
    DEAD_BRAIN_CORAL_FAN(),
    DEAD_BRAIN_CORAL_WALL_FAN(),
    DEAD_BUBBLE_CORAL(),
    DEAD_BUBBLE_CORAL_BLOCK(),
    DEAD_BUBBLE_CORAL_FAN(),
    DEAD_BUBBLE_CORAL_WALL_FAN(),
    DEAD_BUSH(32),
    DEAD_FIRE_CORAL(),
    DEAD_FIRE_CORAL_BLOCK(),
    DEAD_FIRE_CORAL_FAN(),
    DEAD_FIRE_CORAL_WALL_FAN(),
    DEAD_HORN_CORAL(),
    DEAD_HORN_CORAL_BLOCK(),
    DEAD_HORN_CORAL_FAN(),
    DEAD_HORN_CORAL_WALL_FAN(),
    DEAD_TUBE_CORAL(),
    DEAD_TUBE_CORAL_BLOCK(),
    DEAD_TUBE_CORAL_FAN(),
    DEAD_TUBE_CORAL_WALL_FAN(),
    DEBUG_STICK(),
    DETECTOR_RAIL(28, CMIMC.RAIL),
    DIAMOND(264),
    DIAMOND_AXE(279, CMIMC.WEAPON, CMIMC.TOOL, CMIMC.AXE),
    DIAMOND_BLOCK(57, "Block of Diamond"),
    DIAMOND_BOOTS(313, CMIMC.ARMOR, CMIMC.BOOTS),
    DIAMOND_CHESTPLATE(311, CMIMC.ARMOR, CMIMC.CHESTPLATE),
    DIAMOND_HELMET(310, CMIMC.ARMOR, CMIMC.HELMET),
    DIAMOND_HOE(293, CMIMC.TOOL, CMIMC.HOE),
    DIAMOND_HORSE_ARMOR(419, "Diamond_barding"),
    DIAMOND_LEGGINGS(312, CMIMC.ARMOR, CMIMC.LEGGINGS),
    DIAMOND_ORE(56),
    DIAMOND_PICKAXE(278, CMIMC.TOOL, CMIMC.PICKAXE),
    DIAMOND_SHOVEL(277, "DIAMOND_SPADE", CMIMC.TOOL, CMIMC.SHOVEL),
    DIAMOND_SWORD(276, CMIMC.WEAPON),
    DIORITE(1, 3),
    DIRT(3),
    DISPENSER(23),
    DOLPHIN_SPAWN_EGG(CMIMC.SPAWNEGG),
    DONKEY_SPAWN_EGG(383, 31, "Spawn Donkey", CMIMC.SPAWNEGG),
    DRAGON_BREATH(437, "Dragon's Breath"),
    DRAGON_EGG(122, CMIMC.EGG),
    DRAGON_HEAD(397, 5, CMIMC.MONSTERHEAD),
    DRAGON_WALL_HEAD(144, 5, CMIMC.MONSTERHEAD),
    DRIED_KELP(),
    DRIED_KELP_BLOCK(),
    DROPPER(158),
    DROWNED_SPAWN_EGG(CMIMC.SPAWNEGG),
    EGG(344),
    ELDER_GUARDIAN_SPAWN_EGG(383, 4, "Spawn Elder Guardian", CMIMC.SPAWNEGG),
    ELYTRA(443),
    EMERALD(388),
    EMERALD_BLOCK(133, "Block of Emerald"),
    EMERALD_ORE(129),
    ENCHANTED_BOOK(403),
    ENCHANTED_GOLDEN_APPLE(322, 1),
    ENCHANTING_TABLE(116, "ENCHANTMENT_TABLE"),
    ENDERMAN_SPAWN_EGG(383, 58, "Spawn Enderman", CMIMC.SPAWNEGG),
    ENDERMITE_SPAWN_EGG(383, 67, "Spawn Endermite", CMIMC.SPAWNEGG),
    ENDER_CHEST(130),
    ENDER_EYE(381),
    ENDER_PEARL(368),
    END_CRYSTAL(426),
    END_GATEWAY(209),
    END_PORTAL(119),
    END_PORTAL_FRAME(120),
    END_ROD(198),
    END_STONE(121, "ENDER_STONE"),
    END_STONE_BRICKS(206, "END_BRICKS"),
    EVOKER_SPAWN_EGG(383, 34, "Spawn Evoker", CMIMC.SPAWNEGG),
    EXPERIENCE_BOTTLE(384, "Bottle of Enchanting", "expbottle", "Bottle o' Enchanting"),
    FARMLAND(60, "SOIL"),
    FEATHER(288),
    FERMENTED_SPIDER_EYE(376),
    FERN(31, 2, "LONG_GRASS"),
    FILLED_MAP(358),
    FIRE(51, "Fire"),
    FIREWORK_ROCKET(401, "Firework"),
    FIREWORK_STAR(402, "FIREWORK_CHARGE"),
    FIRE_CHARGE(385, "Fireball"),
    FIRE_CORAL(),
    FIRE_CORAL_BLOCK(),
    FIRE_CORAL_FAN(),
    FIRE_CORAL_WALL_FAN(),
    FISHING_ROD(346, CMIMC.TOOL),
    FLINT(318),
    FLINT_AND_STEEL(259),
    FLOWER_POT(390, "FLOWER_POT_ITEM"),
    FROSTED_ICE(212),
    FURNACE(61),
    FURNACE_MINECART(343, "Minecart With Furnace", "POWERED_MINECART"),
    GHAST_SPAWN_EGG(383, 56, "Spawn Ghast", CMIMC.SPAWNEGG),
    GHAST_TEAR(370),
    GLASS(20, CMIMC.SEETHROW),
    GLASS_BOTTLE(374),
    GLASS_PANE(102, CMIMC.SEETHROW, CMIMC.GLASSPANE),
    GLISTERING_MELON_SLICE(382, "Glistering Melon", "speckledmelon"),
    GLOWSTONE(89),
    GLOWSTONE_DUST(348),
    GOLDEN_APPLE(322, "Gold apple"),
    GOLDEN_AXE(286, "Gold Axe", CMIMC.WEAPON, CMIMC.TOOL, CMIMC.AXE),
    GOLDEN_BOOTS(317, "Gold Boots", CMIMC.ARMOR, CMIMC.BOOTS),
    GOLDEN_CARROT(396, "Gold Carrot"),
    GOLDEN_CHESTPLATE(315, "Gold Chestplate", CMIMC.ARMOR, CMIMC.CHESTPLATE),
    GOLDEN_HELMET(314, "Gold Helmet", CMIMC.ARMOR, CMIMC.HELMET),
    GOLDEN_HOE(294, "Gold Hoe", CMIMC.TOOL, CMIMC.HOE),
    GOLDEN_HORSE_ARMOR(418, "Gold Barding"),
    GOLDEN_LEGGINGS(316, "Gold Leggings", CMIMC.ARMOR, CMIMC.LEGGINGS),
    GOLDEN_PICKAXE(285, "Gold Pickaxe", CMIMC.TOOL, CMIMC.PICKAXE),
    GOLDEN_SHOVEL(284, "Gold Spade", CMIMC.TOOL, CMIMC.SHOVEL),
    GOLDEN_SWORD(283, "Gold Sword", CMIMC.WEAPON),
    GOLD_BLOCK(41),
    GOLD_INGOT(266),
    GOLD_NUGGET(371),
    GOLD_ORE(14),
    GRANITE(1, 1),
    GRASS(31, 1),
    GRASS_BLOCK(2),
    GRAVEL(13),
    GRAY_BANNER(425, 8),
    GRAY_BED(355, 7, CMIMC.BED),
    GRAY_CARPET(171, 7, CMIMC.CARPET),
    GRAY_CONCRETE(251, 7),
    GRAY_CONCRETE_POWDER(252, 7),
    GRAY_DYE(351, 8, CMIMC.DYE),
    GRAY_GLAZED_TERRACOTTA(242),
    GRAY_SHULKER_BOX(226, CMIMC.SHULKERBOX),
    GRAY_STAINED_GLASS(95, 7, CMIMC.SEETHROW),
    GRAY_STAINED_GLASS_PANE(160, 7, CMIMC.SEETHROW, CMIMC.GLASSPANE),
    GRAY_TERRACOTTA(159, 7),
    GRAY_WALL_BANNER(177, 8),
    GRAY_WOOL(35, 7, CMIMC.WOOL),
    GREEN_BANNER(425, 2),
    GREEN_BED(355, 13, CMIMC.BED),
    GREEN_CARPET(171, 13, CMIMC.CARPET),
    GREEN_CONCRETE(251, 13),
    GREEN_CONCRETE_POWDER(252, 13),
    GREEN_GLAZED_TERRACOTTA(248),
    GREEN_SHULKER_BOX(232, CMIMC.SHULKERBOX),
    GREEN_STAINED_GLASS(95, 13, CMIMC.SEETHROW),
    GREEN_STAINED_GLASS_PANE(160, 13, CMIMC.SEETHROW, CMIMC.GLASSPANE),
    GREEN_TERRACOTTA(159, 13),
    GREEN_WALL_BANNER(177, 2),
    GREEN_WOOL(35, 13, CMIMC.WOOL),
    GUARDIAN_SPAWN_EGG(383, 68, "Spawn Guardian", CMIMC.SPAWNEGG),
    GUNPOWDER(289, "SULPHUR"),
    HAY_BLOCK(170, "Hay Bale"),
    HEART_OF_THE_SEA(),
    HEAVY_WEIGHTED_PRESSURE_PLATE(148, "IRON_PLATE", CMIMC.PRESSUREPLATE),
    HOPPER(154),
    HOPPER_MINECART(408, "Minecart With Hopper"),
    HORN_CORAL(),
    HORN_CORAL_BLOCK(),
    HORN_CORAL_FAN(),
    HORN_CORAL_WALL_FAN(),
    HORSE_SPAWN_EGG(383, 100, "Spawn Horse", CMIMC.SPAWNEGG),
    HUSK_SPAWN_EGG(383, 23, "Spawn Husk", CMIMC.SPAWNEGG),
    ICE(79),
    INFESTED_CHISELED_STONE_BRICKS(97, 5, "MONSTER_EGGS"),
    INFESTED_COBBLESTONE(97, 1),
    INFESTED_CRACKED_STONE_BRICKS(97, 4),
    INFESTED_MOSSY_STONE_BRICKS(97, 3),
    INFESTED_STONE(97),
    INFESTED_STONE_BRICKS(97, 2),
    INK_SAC(351, CMIMC.DYE),
    IRON_AXE(258, CMIMC.WEAPON, CMIMC.TOOL, CMIMC.AXE),
    IRON_BARS(101, "Iron Fence", CMIMC.SEETHROW),
    IRON_BLOCK(42, "Block of Iron"),
    IRON_BOOTS(309, CMIMC.ARMOR, CMIMC.BOOTS),
    IRON_CHESTPLATE(307, CMIMC.ARMOR, CMIMC.CHESTPLATE),
    IRON_DOOR(330, CMIMC.DOOR),
    IRON_HELMET(306, CMIMC.ARMOR, CMIMC.HELMET),
    IRON_HOE(292, CMIMC.TOOL, CMIMC.HOE),
    IRON_HORSE_ARMOR(417, "Iron Barding"),
    IRON_INGOT(265),
    IRON_LEGGINGS(308, CMIMC.ARMOR, CMIMC.LEGGINGS),
    IRON_NUGGET(452),
    IRON_ORE(15),
    IRON_PICKAXE(257, CMIMC.TOOL, CMIMC.PICKAXE),
    IRON_SHOVEL(256, "Iron Spade", CMIMC.TOOL, CMIMC.SHOVEL),
    IRON_SWORD(267, CMIMC.WEAPON),
    IRON_TRAPDOOR(167, CMIMC.TRAPDOOR),
    ITEM_FRAME(389),
    JACK_O_LANTERN(91, "Jack o'Lantern"),
    JUKEBOX(84),
    JUNGLE_BOAT(446, "Boat Jungle", CMIMC.BOAT),
    JUNGLE_BUTTON(CMIMC.BUTTON),
    JUNGLE_DOOR(429, "Jungle Door Item", CMIMC.DOOR),
    JUNGLE_FENCE(190, CMIMC.SEETHROW, CMIMC.FENCE),
    JUNGLE_FENCE_GATE(185, CMIMC.SEETHROW, CMIMC.FENCEGATE),
    JUNGLE_LEAVES(18, 3),
    JUNGLE_LOG(17, 3),
    JUNGLE_PLANKS(5, 3, "Jungle Wood Plank"),
    JUNGLE_PRESSURE_PLATE(CMIMC.PRESSUREPLATE),
    JUNGLE_SAPLING(6, 3, CMIMC.SAPLING),
    JUNGLE_SLAB(43, CMIMC.SLAB),
    JUNGLE_STAIRS(136, "Jungle Wood Stairs", CMIMC.STAIRS),
    JUNGLE_TRAPDOOR(CMIMC.TRAPDOOR),
    JUNGLE_WOOD(),
    KELP(),
    KELP_PLANT(),
    KNOWLEDGE_BOOK(453),
    LADDER(65),
    LAPIS_BLOCK(22, "Lapis Lazuli Block"),
    LAPIS_LAZULI(351, 4, CMIMC.DYE),
    LAPIS_ORE(21, "Lapis Lazuli Ore"),
    LARGE_FERN(175, 3, "DOUBLE_PLANT"),
    LAVA(10, "Flowing Lava"),
    LAVA_BUCKET(327),
    LEAD(420, "Leash"),
    LEATHER(334),
    LEATHER_BOOTS(301, CMIMC.ARMOR, CMIMC.LEATHER, CMIMC.BOOTS),
    LEATHER_CHESTPLATE(299, "Leather Tunic", CMIMC.ARMOR, CMIMC.LEATHER, CMIMC.CHESTPLATE),
    LEATHER_HELMET(298, "Leather Cap", CMIMC.ARMOR, CMIMC.LEATHER, CMIMC.HELMET),
    LEATHER_LEGGINGS(300, "Leather Pants", CMIMC.ARMOR, CMIMC.LEATHER, CMIMC.LEGGINGS),
    LEVER(69),
    LIGHT_BLUE_BANNER(425, 12),
    LIGHT_BLUE_BED(355, 3, CMIMC.BED),
    LIGHT_BLUE_CARPET(171, 3, CMIMC.CARPET),
    LIGHT_BLUE_CONCRETE(251, 3),
    LIGHT_BLUE_CONCRETE_POWDER(252, 3),
    LIGHT_BLUE_DYE(351, 12, CMIMC.DYE),
    LIGHT_BLUE_GLAZED_TERRACOTTA(238),
    LIGHT_BLUE_SHULKER_BOX(222, CMIMC.SHULKERBOX),
    LIGHT_BLUE_STAINED_GLASS(95, 3, CMIMC.SEETHROW),
    LIGHT_BLUE_STAINED_GLASS_PANE(160, 3, CMIMC.SEETHROW, CMIMC.GLASSPANE),
    LIGHT_BLUE_TERRACOTTA(159, 3),
    LIGHT_BLUE_WALL_BANNER(177, 12),
    LIGHT_BLUE_WOOL(35, 3, CMIMC.WOOL),
    LIGHT_GRAY_BANNER(425, 7),
    LIGHT_GRAY_BED(355, 8, CMIMC.BED),
    LIGHT_GRAY_CARPET(171, 8, CMIMC.CARPET),
    LIGHT_GRAY_CONCRETE(251, 8),
    LIGHT_GRAY_CONCRETE_POWDER(252, 8),
    LIGHT_GRAY_DYE(351, 7, CMIMC.DYE),
    LIGHT_GRAY_GLAZED_TERRACOTTA(243, "SILVER_GLAZED_TERRACOTTA"),
    LIGHT_GRAY_SHULKER_BOX(227, "SILVER_SHULKER_BOX", CMIMC.SHULKERBOX),
    LIGHT_GRAY_STAINED_GLASS(95, 8, CMIMC.SEETHROW),
    LIGHT_GRAY_STAINED_GLASS_PANE(160, 8, CMIMC.SEETHROW, CMIMC.GLASSPANE),
    LIGHT_GRAY_TERRACOTTA(159, 8),
    LIGHT_GRAY_WALL_BANNER(177, 7),
    LIGHT_GRAY_WOOL(35, 8, CMIMC.WOOL),
    LIGHT_WEIGHTED_PRESSURE_PLATE(147, 0, "GOLD_PLATE", CMIMC.PRESSUREPLATE),
    LILAC(175, 1, CMIMC.DOUBLEPLANT),
    LILY_PAD(111, "WATER_LILY"),
    LIME_BANNER(425, 10),
    LIME_BED(355, 5, CMIMC.BED),
    LIME_CARPET(171, 5, CMIMC.CARPET),
    LIME_CONCRETE(251, 5),
    LIME_CONCRETE_POWDER(252, 5),
    LIME_DYE(351, 10, CMIMC.DYE),
    LIME_GLAZED_TERRACOTTA(240),
    LIME_SHULKER_BOX(224, CMIMC.SHULKERBOX),
    LIME_STAINED_GLASS(95, 5, CMIMC.SEETHROW),
    LIME_STAINED_GLASS_PANE(160, 5, CMIMC.SEETHROW, CMIMC.GLASSPANE),
    LIME_TERRACOTTA(159, 5),
    LIME_WALL_BANNER(177, 10),
    LIME_WOOL(35, 5, CMIMC.WOOL),
    LINGERING_POTION(441, CMIMC.POTION),
    LLAMA_SPAWN_EGG(383, 103, "Spawn Llama", CMIMC.SPAWNEGG),
    MAGENTA_BANNER(425, 13),
    MAGENTA_BED(355, 2, CMIMC.BED),
    MAGENTA_CARPET(171, 2, CMIMC.CARPET),
    MAGENTA_CONCRETE(251, 2),
    MAGENTA_CONCRETE_POWDER(252, 2),
    MAGENTA_DYE(351, 13, CMIMC.DYE),
    MAGENTA_GLAZED_TERRACOTTA(237),
    MAGENTA_SHULKER_BOX(221, CMIMC.SHULKERBOX),
    MAGENTA_STAINED_GLASS(95, 2, CMIMC.SEETHROW),
    MAGENTA_STAINED_GLASS_PANE(160, 2, CMIMC.SEETHROW, CMIMC.GLASSPANE),
    MAGENTA_TERRACOTTA(159, 2),
    MAGENTA_WALL_BANNER(177, 13),
    MAGENTA_WOOL(35, 2, CMIMC.WOOL),
    MAGMA_BLOCK(213, "MAGMA"),
    MAGMA_CREAM(378),
    MAGMA_CUBE_SPAWN_EGG(383, 62, "Spawn Magma Cube", CMIMC.SPAWNEGG),
    MAP(395, "Empty Map"),
    MELON(103, "Melon_Block"),
    MELON_SEEDS(362),
    MELON_SLICE(360),
    MELON_STEM(105),
    MILK_BUCKET(335),
    MINECART(328),
    MOOSHROOM_SPAWN_EGG(383, 96, "Spawn Mushroom Cow", CMIMC.SPAWNEGG),
    MOSSY_COBBLESTONE(48),
    MOSSY_COBBLESTONE_WALL(139, 1, CMIMC.WALL),
    MOSSY_STONE_BRICKS(98, 1),
    MOVING_PISTON(36, "Piston Moving Piece"),
    MULE_SPAWN_EGG(383, 32, "Spawn Mule", CMIMC.SPAWNEGG),
    MUSHROOM_STEM(),
    MUSHROOM_STEW(282, "MUSHROOM_SOUP"),
    MUSIC_DISC_11(2266, "11 Disc", "RECORD_11"),
    MUSIC_DISC_13(2256, "13 Disc", "GOLD_RECORD"),
    MUSIC_DISC_BLOCKS(2258, "Blocks Disc", "RECORD_3"),
    MUSIC_DISC_CAT(2257, "Cat Disc", "GREEN_RECORD"),
    MUSIC_DISC_CHIRP(2259, "Chirp Disc", "RECORD_4"),
    MUSIC_DISC_FAR(2260, "Far Disc", "RECORD_5"),
    MUSIC_DISC_MALL(2261, "Mall Disc", "RECORD_6"),
    MUSIC_DISC_MELLOHI(2262, "Mellohi Disc", "RECORD_7"),
    MUSIC_DISC_STAL(2263, "Stal Disc", "RECORD_8"),
    MUSIC_DISC_STRAD(2264, "Strad Disc", "RECORD_9"),
    MUSIC_DISC_WAIT(2267, "Wait Disc", "RECORD_12"),
    MUSIC_DISC_WARD(2265, "Ward Disc", "RECORD_10"),
    MUTTON(423, "Raw Mutton"),
    MYCELIUM(110, "MYCEL"),
    NAME_TAG(421),
    NAUTILUS_SHELL(),
    NETHERRACK(87),
    NETHER_BRICK(405, "Nether Brick Item"),
    NETHER_BRICKS(112),
    NETHER_BRICK_FENCE(113, "NETHER_FENCE", CMIMC.SEETHROW, CMIMC.FENCE),
    NETHER_BRICK_SLAB(44, 6, CMIMC.SLAB),
    NETHER_BRICK_STAIRS(114, CMIMC.STAIRS),
    NETHER_PORTAL(90, "PORTAL"),
    NETHER_QUARTZ_ORE(153, "QUARTZ_ORE"),
    NETHER_STAR(399),
    NETHER_WART(372, "NETHER_STALK"),
    NETHER_WART_BLOCK(214),
    NOTE_BLOCK(25),
    OAK_BOAT(333, "Boat", CMIMC.BOAT),
    OAK_BUTTON(143, "Wooden_button", CMIMC.BUTTON),
    OAK_DOOR(324, "Wooden Door", "Wood Door", "Door", CMIMC.DOOR),
    OAK_FENCE(85, "Fence", CMIMC.SEETHROW, CMIMC.FENCE),
    OAK_FENCE_GATE(107, "FENCE_GATE", CMIMC.SEETHROW, CMIMC.FENCEGATE),
    OAK_LEAVES(18),
    OAK_LOG(17),
    OAK_PLANKS(5, "Oak Wood Plank"),
    OAK_PRESSURE_PLATE(72, "Wooden_Presure_Plate", CMIMC.PRESSUREPLATE),
    OAK_SAPLING(6, "Sapling", CMIMC.SAPLING),
    OAK_SLAB(126, "Wood step", CMIMC.SLAB),
    OAK_STAIRS(53, "WOOD_STAIRS", CMIMC.STAIRS),
    OAK_TRAPDOOR(96, "Trapdoor", CMIMC.TRAPDOOR),
    OAK_WOOD(),
    OBSERVER(218),
    OBSIDIAN(49),
    OCELOT_SPAWN_EGG(383, 98, "Spawn Ocelot", CMIMC.SPAWNEGG),
    ORANGE_BANNER(425, 14),
    ORANGE_BED(355, 1, CMIMC.BED),
    ORANGE_CARPET(171, 1, CMIMC.CARPET),
    ORANGE_CONCRETE(251, 1),
    ORANGE_CONCRETE_POWDER(252, 1),
    ORANGE_DYE(351, 14, CMIMC.DYE),
    ORANGE_GLAZED_TERRACOTTA(236),
    ORANGE_SHULKER_BOX(220, CMIMC.SHULKERBOX),
    ORANGE_STAINED_GLASS(95, 1, CMIMC.SEETHROW),
    ORANGE_STAINED_GLASS_PANE(160, 1, CMIMC.SEETHROW, CMIMC.GLASSPANE),
    ORANGE_TERRACOTTA(159, 1),
    ORANGE_TULIP(38, 5),
    ORANGE_WALL_BANNER(177, 114),
    ORANGE_WOOL(35, 1, CMIMC.WOOL),
    OXEYE_DAISY(38, 8),
    PACKED_ICE(174),
    PAINTING(321),
    PAPER(339),
    PARROT_SPAWN_EGG(383, 105, "Spawn Parrot", CMIMC.SPAWNEGG),
    PEONY(175, 5, CMIMC.DOUBLEPLANT),
    PETRIFIED_OAK_SLAB(CMIMC.SLAB),
    PHANTOM_MEMBRANE(),
    PHANTOM_SPAWN_EGG(CMIMC.SPAWNEGG),
    PIG_SPAWN_EGG(383, 90, "Spawn Pig", CMIMC.SPAWNEGG),
    PINK_BANNER(425, 9),
    PINK_BED(355, 6, CMIMC.BED),
    PINK_CARPET(171, 6, CMIMC.CARPET),
    PINK_CONCRETE(251, 6),
    PINK_CONCRETE_POWDER(252, 6),
    PINK_DYE(351, 9, CMIMC.DYE),
    PINK_GLAZED_TERRACOTTA(241),
    PINK_SHULKER_BOX(225, CMIMC.SHULKERBOX),
    PINK_STAINED_GLASS(95, 6, CMIMC.SEETHROW),
    PINK_STAINED_GLASS_PANE(160, 6, CMIMC.SEETHROW, CMIMC.GLASSPANE),
    PINK_TERRACOTTA(159, 6),
    PINK_TULIP(38, 7),
    PINK_WALL_BANNER(177, 9),
    PINK_WOOL(35, 6, CMIMC.WOOL),
    PISTON(33, "PISTON_BASE"),
    PISTON_HEAD(34, "PISTON_EXTENSION"),
    PLAYER_HEAD(397, 3, "Mob Head (Human)", CMIMC.PLAYERHEAD),
    PLAYER_WALL_HEAD(144, 3, CMIMC.PLAYERHEAD),
    PODZOL(3, 2),
    POISONOUS_POTATO(394),
    POLAR_BEAR_SPAWN_EGG(383, 102, "Spawn Polar Bear", CMIMC.SPAWNEGG),
    POLISHED_ANDESITE(1, 6),
    POLISHED_DIORITE(1, 4),
    POLISHED_GRANITE(1, 2),
    POPPED_CHORUS_FRUIT(433),
    POPPY(38),
    PORKCHOP(319, "Raw Porkchop"),
    POTATO(392, "Potatoitem"),
    POTATOES(142, "Potatoes"),
    POTION(373, CMIMC.POTION),
    POTTED_ACACIA_SAPLING(CMIMC.POTTED),
    POTTED_ALLIUM(CMIMC.POTTED),
    POTTED_AZURE_BLUET(CMIMC.POTTED),
    POTTED_BIRCH_SAPLING(CMIMC.POTTED),
    POTTED_BLUE_ORCHID(CMIMC.POTTED),
    POTTED_BROWN_MUSHROOM(CMIMC.POTTED),
    POTTED_CACTUS(CMIMC.POTTED),
    POTTED_DANDELION(CMIMC.POTTED),
    POTTED_DARK_OAK_SAPLING(CMIMC.POTTED),
    POTTED_DEAD_BUSH(CMIMC.POTTED),
    POTTED_FERN(CMIMC.POTTED),
    POTTED_JUNGLE_SAPLING(CMIMC.POTTED),
    POTTED_OAK_SAPLING(CMIMC.POTTED),
    POTTED_ORANGE_TULIP(CMIMC.POTTED),
    POTTED_OXEYE_DAISY(CMIMC.POTTED),
    POTTED_PINK_TULIP(CMIMC.POTTED),
    POTTED_POPPY(CMIMC.POTTED),
    POTTED_RED_MUSHROOM(CMIMC.POTTED),
    POTTED_RED_TULIP(CMIMC.POTTED),
    POTTED_SPRUCE_SAPLING(CMIMC.POTTED),
    POTTED_WHITE_TULIP(CMIMC.POTTED),
    POWERED_RAIL(27, CMIMC.RAIL),
    PRISMARINE(168),
    PRISMARINE_BRICKS(168, 1),
    PRISMARINE_BRICK_SLAB(CMIMC.SLAB),
    PRISMARINE_BRICK_STAIRS(CMIMC.STAIRS),
    PRISMARINE_CRYSTALS(410),
    PRISMARINE_SHARD(409),
    PRISMARINE_SLAB(31323, CMIMC.SLAB),
    PRISMARINE_STAIRS(CMIMC.STAIRS),
    PUFFERFISH(349, 3),
    PUFFERFISH_BUCKET("Bucket of Pufferfish", CMIMC.BUCKETANIMAL),
    PUFFERFISH_SPAWN_EGG(CMIMC.SPAWNEGG),
    PUMPKIN(86),
    PUMPKIN_PIE(400),
    PUMPKIN_SEEDS(361),
    PUMPKIN_STEM(104),
    PURPLE_BANNER(425, 5),
    PURPLE_BED(355, 10, CMIMC.BED),
    PURPLE_CARPET(171, 10, CMIMC.CARPET),
    PURPLE_CONCRETE(251, 10),
    PURPLE_CONCRETE_POWDER(252, 10),
    PURPLE_DYE(351, 5, CMIMC.DYE),
    PURPLE_GLAZED_TERRACOTTA(245),
    PURPLE_SHULKER_BOX(229, CMIMC.SHULKERBOX),
    PURPLE_STAINED_GLASS(95, 10, CMIMC.SEETHROW),
    PURPLE_STAINED_GLASS_PANE(160, 10, CMIMC.SEETHROW, CMIMC.GLASSPANE),
    PURPLE_TERRACOTTA(159, 10),
    PURPLE_WALL_BANNER(177, 5),
    PURPLE_WOOL(35, 10, CMIMC.WOOL),
    PURPUR_BLOCK(201),
    PURPUR_PILLAR(202),
    PURPUR_SLAB(205, CMIMC.SLAB),
    PURPUR_STAIRS(203, CMIMC.STAIRS),
    QUARTZ(406),
    QUARTZ_BLOCK(155, "Block of Quartz"),
    QUARTZ_PILLAR(155, 2),
    QUARTZ_SLAB(44, 7, CMIMC.SLAB),
    QUARTZ_STAIRS(156, CMIMC.STAIRS),
    RABBIT(411, "Raw Rabbit"),
    RABBIT_FOOT(414, "Rabbit's Foot"),
    RABBIT_HIDE(415),
    RABBIT_SPAWN_EGG(383, 101, "Spawn Rabbit", CMIMC.SPAWNEGG),
    RABBIT_STEW(413),
    RAIL(66, "Rails", CMIMC.RAIL),
    REDSTONE(331, "Redstone Dust"),
    REDSTONE_BLOCK(152, "Block of Redstone"),
    REDSTONE_LAMP(123, "REDSTONE_LAMP_OFF"),
    REDSTONE_ORE(73),
    REDSTONE_TORCH(76, "Redstone Torch(on)", "REDSTONE_TORCH_ON"),
    REDSTONE_WALL_TORCH(76),
    REDSTONE_WIRE(55),
    RED_BANNER(425, 1),
    RED_BED(355, 14, CMIMC.BED),
    RED_CARPET(171, 14, CMIMC.CARPET),
    RED_CONCRETE(251, 14),
    RED_CONCRETE_POWDER(252, 14),
    RED_GLAZED_TERRACOTTA(249),
    RED_MUSHROOM(40),
    RED_MUSHROOM_BLOCK(100, "HUGE_MUSHROOM_2"),
    RED_NETHER_BRICKS(215, "RED_NETHER_BRICK"),
    RED_SAND(12, 1),
    RED_SANDSTONE(179),
    RED_SANDSTONE_SLAB(182, "STONE_SLAB2", CMIMC.SLAB),
    RED_SANDSTONE_STAIRS(180, CMIMC.STAIRS),
    RED_SHULKER_BOX(233, CMIMC.SHULKERBOX),
    RED_STAINED_GLASS(95, 14, CMIMC.SEETHROW),
    RED_STAINED_GLASS_PANE(160, 14, CMIMC.SEETHROW, CMIMC.GLASSPANE),
    RED_TERRACOTTA(159, 14),
    RED_TULIP(38, 4),
    RED_WALL_BANNER(177, 1),
    RED_WOOL(35, 14, CMIMC.WOOL),
    REPEATER(356, "Redstone Repeater", "Diode"),
    REPEATING_COMMAND_BLOCK(),
    ROSE_BUSH(175, 4, CMIMC.DOUBLEPLANT),
    ROSE_RED(351, 1, CMIMC.DYE),
    ROTTEN_FLESH(367),
    SADDLE(329),
    SALMON(349, 1, "Raw Salmon"),
    SALMON_BUCKET(CMIMC.BUCKETANIMAL),
    SALMON_SPAWN_EGG(CMIMC.SPAWNEGG),
    SAND(12),
    SANDSTONE(24),
    SANDSTONE_SLAB(44, 1, CMIMC.SLAB),
    SANDSTONE_STAIRS(128, CMIMC.STAIRS),
    SCUTE(),
    SEAGRASS(),
    SEA_LANTERN(169),
    SEA_PICKLE(),
    SHEARS(359, CMIMC.TOOL),
    SHEEP_SPAWN_EGG(383, 91, CMIMC.SPAWNEGG),
    SHIELD(442),
    SHULKER_BOX(229, CMIMC.SHULKERBOX),
    SHULKER_SHELL(450),
    SHULKER_SPAWN_EGG(383, 69, CMIMC.SPAWNEGG),
    SILVERFISH_SPAWN_EGG(383, 60, CMIMC.SPAWNEGG),
    SKELETON_HORSE_SPAWN_EGG(383, 28, CMIMC.SPAWNEGG),
    SKELETON_SKULL(397, "Mob Head (Skeleton)", CMIMC.SKULL),
    SKELETON_SPAWN_EGG(383, 51, CMIMC.SPAWNEGG),
    SKELETON_WALL_SKULL(144, CMIMC.SKULL),
    SLIME_BALL(341),
    SLIME_BLOCK(165),
    SLIME_SPAWN_EGG(383, 55, CMIMC.SPAWNEGG),
    SMOOTH_QUARTZ(),
    SMOOTH_RED_SANDSTONE(179, 2),
    SMOOTH_SANDSTONE(24, 2),
    SMOOTH_STONE(),
    SNOW(78),
    SNOWBALL(332),
    SNOW_BLOCK(80),
    SOUL_SAND(88),
    SPAWNER(52, 90, "MOB_SPAWNER"),
    SPECTRAL_ARROW(439),
    SPIDER_EYE(375),
    SPIDER_SPAWN_EGG(383, 52, CMIMC.SPAWNEGG),
    SPLASH_POTION(438, CMIMC.POTION),
    SPONGE(19),
    SPRUCE_BOAT(444, "BOAT_SPRUCE", CMIMC.BOAT),
    SPRUCE_BUTTON(CMIMC.BUTTON),
    SPRUCE_DOOR(427, "SPRUCE_DOOR_ITEM", CMIMC.DOOR),
    SPRUCE_FENCE(188, CMIMC.SEETHROW, CMIMC.FENCE),
    SPRUCE_FENCE_GATE(183, CMIMC.SEETHROW, CMIMC.FENCEGATE),
    SPRUCE_LEAVES(18, 1),
    SPRUCE_LOG(17, 1),
    SPRUCE_PLANKS(5, 1, "Spruce Wood Plank"),
    SPRUCE_PRESSURE_PLATE(CMIMC.PRESSUREPLATE),
    SPRUCE_SAPLING(6, 1, CMIMC.SAPLING),
    SPRUCE_SLAB(126, 1, CMIMC.SLAB),
    SPRUCE_STAIRS(134, "Spruce Wood Stairs", CMIMC.STAIRS),
    SPRUCE_TRAPDOOR(CMIMC.TRAPDOOR),
    SPRUCE_WOOD(),
    SQUID_SPAWN_EGG(383, 94, CMIMC.SPAWNEGG),
    STICK(280),
    STICKY_PISTON(29, "PISTON_STICKY_BASE"),
    STONE(1),
    STONE_AXE(275, CMIMC.WEAPON, CMIMC.TOOL, CMIMC.AXE),
    STONE_BRICKS(98),
    STONE_BRICK_SLAB(44, 5, CMIMC.SLAB),
    STONE_BRICK_STAIRS(109, "SMOOTH_STAIRS", CMIMC.STAIRS),
    STONE_BUTTON(77, CMIMC.BUTTON),
    STONE_HOE(291, CMIMC.TOOL, CMIMC.HOE),
    STONE_PICKAXE(274, CMIMC.TOOL, CMIMC.PICKAXE),
    STONE_PRESSURE_PLATE(70, "STONE_PLATE", CMIMC.PRESSUREPLATE),
    STONE_SHOVEL(273, "STONE_SPADE", CMIMC.TOOL, CMIMC.SHOVEL),
    STONE_SLAB(44, CMIMC.SLAB),
    STONE_SWORD(272, CMIMC.WEAPON),
    STRAY_SPAWN_EGG(383, 6, CMIMC.SPAWNEGG),
    STRING(287),
    STRIPPED_ACACIA_LOG(),
    STRIPPED_ACACIA_WOOD(),
    STRIPPED_BIRCH_LOG(),
    STRIPPED_BIRCH_WOOD(),
    STRIPPED_DARK_OAK_LOG(),
    STRIPPED_DARK_OAK_WOOD(),
    STRIPPED_JUNGLE_LOG(),
    STRIPPED_JUNGLE_WOOD(),
    STRIPPED_OAK_LOG(),
    STRIPPED_OAK_WOOD(),
    STRIPPED_SPRUCE_LOG(),
    STRIPPED_SPRUCE_WOOD(),
    STRUCTURE_BLOCK(255),
    STRUCTURE_VOID(217),
    SUGAR(353),
    SUGAR_CANE(338, "Sugar Canes"),
    SUNFLOWER(175, CMIMC.DOUBLEPLANT),
    TALL_GRASS(31),
    TALL_SEAGRASS(),
    TERRACOTTA(172, "HARD_CLAY"),
    TIPPED_ARROW(440),
    TNT(46),
    TNT_MINECART(407, "Minecart With TNT", "explosiveminecart"),
    TORCH(50),
    TOTEM_OF_UNDYING(449, "Totem"),
    TRAPPED_CHEST(146),
    TRIDENT(CMIMC.WEAPON),
    TRIPWIRE(132),
    TRIPWIRE_HOOK(131),
    TROPICAL_FISH(349, 2),
    TROPICAL_FISH_BUCKET(CMIMC.BUCKETANIMAL),
    TROPICAL_FISH_SPAWN_EGG(CMIMC.SPAWNEGG),
    TUBE_CORAL(),
    TUBE_CORAL_BLOCK(),
    TUBE_CORAL_FAN(),
    TUBE_CORAL_WALL_FAN(),
    TURTLE_EGG(CMIMC.EGG),
    TURTLE_HELMET(CMIMC.ARMOR, CMIMC.HELMET),
    TURTLE_SPAWN_EGG(CMIMC.SPAWNEGG),
    VEX_SPAWN_EGG(383, 35, CMIMC.SPAWNEGG),
    VILLAGER_SPAWN_EGG(383, 120, CMIMC.SPAWNEGG),
    VINDICATOR_SPAWN_EGG(383, 36, CMIMC.SPAWNEGG),
    VINE(106, "Vines", CMIMC.SEETHROW),
    VOID_AIR(CMIMC.AIR),
    WALL_SIGN(68, CMIMC.SIGN, CMIMC.WALLSIGN),
    WALL_TORCH(50),
    WATER(8, "Flowing Water"),
    WATER_BUCKET(326),
    WET_SPONGE(19, 1),
    WHEAT(296),
    WHEAT_SEEDS(295, "SEEDS"),
    WHITE_BANNER(425, 15),
    WHITE_BED(355, "Bed", CMIMC.BED),
    WHITE_CARPET(171, CMIMC.CARPET),
    WHITE_CONCRETE(251),
    WHITE_CONCRETE_POWDER(252),
    WHITE_GLAZED_TERRACOTTA(235),
    WHITE_SHULKER_BOX(219, CMIMC.SHULKERBOX),
    WHITE_STAINED_GLASS(95, CMIMC.SEETHROW),
    WHITE_STAINED_GLASS_PANE(160, CMIMC.SEETHROW, CMIMC.GLASSPANE),
    WHITE_TERRACOTTA(159),
    WHITE_TULIP(38, 6),
    WHITE_WALL_BANNER(425, 15),
    WHITE_WOOL(35, "Wool", CMIMC.WOOL),
    WITCH_SPAWN_EGG(383, 66, CMIMC.SPAWNEGG),
    WITHER_SKELETON_SKULL(397, 1, "Mob Head (Wither Skeleton)", CMIMC.SKULL),
    WITHER_SKELETON_SPAWN_EGG(383, 5, CMIMC.SPAWNEGG),
    WITHER_SKELETON_WALL_SKULL(144, 1, CMIMC.SKULL),
    WOLF_SPAWN_EGG(383, 95, CMIMC.SPAWNEGG),
    WOODEN_AXE(271, "Wood Axe", "Axe", CMIMC.WEAPON, CMIMC.TOOL, CMIMC.AXE),
    WOODEN_HOE(290, "Wood Hoe", "Hoe", CMIMC.TOOL, CMIMC.HOE),
    WOODEN_PICKAXE(270, "WOOD_PICKAXE", "Pickaxe", CMIMC.TOOL, CMIMC.PICKAXE),
    WOODEN_SHOVEL(269, "WOOD_SPADE", "Spade", CMIMC.TOOL, CMIMC.SHOVEL),
    WOODEN_SWORD(268, "WOOD_SWORD", "Sword", CMIMC.WEAPON),
    WRITABLE_BOOK(386, "Book and Quill"),
    WRITTEN_BOOK(387),
    YELLOW_BANNER(425, 11),
    YELLOW_BED(355, 4, CMIMC.BED),
    YELLOW_CARPET(171, 4, CMIMC.CARPET),
    YELLOW_CONCRETE(251, 4),
    YELLOW_CONCRETE_POWDER(252, 4),
    YELLOW_GLAZED_TERRACOTTA(239),
    YELLOW_SHULKER_BOX(223, CMIMC.SHULKERBOX),
    YELLOW_STAINED_GLASS(95, 4, CMIMC.SEETHROW),
    YELLOW_STAINED_GLASS_PANE(160, 4, CMIMC.SEETHROW, CMIMC.GLASSPANE),
    YELLOW_TERRACOTTA(159, 4),
    YELLOW_WALL_BANNER(425, 11),
    YELLOW_WOOL(35, 4, CMIMC.WOOL),
    ZOMBIE_HEAD(397, 2, "Mob Head (Zombie)", CMIMC.MONSTERHEAD),
    ZOMBIE_HORSE_SPAWN_EGG(383, 29, CMIMC.SPAWNEGG),
    ZOMBIE_PIGMAN_SPAWN_EGG(383, 57, CMIMC.SPAWNEGG),
    ZOMBIE_SPAWN_EGG(383, 54, CMIMC.SPAWNEGG),
    ZOMBIE_VILLAGER_SPAWN_EGG(383, 27, CMIMC.SPAWNEGG),
    ZOMBIE_WALL_HEAD(144, 2, CMIMC.MONSTERHEAD),

    //1.14
    ACACIA_SIGN(CMIMC.SIGN),
    ACACIA_WALL_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    ANDESITE_SLAB(CMIMC.SLAB),
    ANDESITE_STAIRS(CMIMC.STAIRS),
    ANDESITE_WALL(CMIMC.WALL),
    BAMBOO(),
    BAMBOO_SAPLING(CMIMC.SAPLING),
    BARREL(),
    BELL(),
    BIRCH_SIGN(CMIMC.SIGN),
    BIRCH_WALL_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    BLACK_DYE(CMIMC.DYE),
    BLAST_FURNACE(),
    BLUE_DYE(CMIMC.DYE),
    BRICK_WALL(CMIMC.WALL),
    BROWN_DYE(CMIMC.DYE),
    CAMPFIRE(),
    CARTOGRAPHY_TABLE(),
    CAT_SPAWN_EGG(CMIMC.SPAWNEGG),
    CORNFLOWER(),
    CREEPER_BANNER_PATTERN(),
    CROSSBOW(CMIMC.WEAPON),
    CUT_RED_SANDSTONE_SLAB(CMIMC.SLAB),
    CUT_SANDSTONE_SLAB(CMIMC.SLAB),
    DARK_OAK_SIGN(CMIMC.SIGN),
    DARK_OAK_WALL_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    DIORITE_SLAB(CMIMC.SLAB),
    DIORITE_STAIRS(CMIMC.STAIRS),
    DIORITE_WALL(CMIMC.WALL),
    END_STONE_BRICK_SLAB(CMIMC.SLAB),
    END_STONE_BRICK_STAIRS(CMIMC.STAIRS),
    END_STONE_BRICK_WALL(),
    FLETCHING_TABLE(),
    FLOWER_BANNER_PATTERN(),
    FOX_SPAWN_EGG(CMIMC.SPAWNEGG),
    GLOBE_BANNER_PATTERN(),
    GRANITE_SLAB(CMIMC.SLAB),
    GRANITE_STAIRS(CMIMC.STAIRS),
    GRANITE_WALL(CMIMC.WALL),
    GREEN_DYE(CMIMC.DYE),
    GRINDSTONE(),
    JIGSAW(),
    JUNGLE_SIGN(CMIMC.SIGN),
    JUNGLE_WALL_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    LANTERN(),
    LEATHER_HORSE_ARMOR(CMIMC.LEATHER),
    LECTERN(),
    LILY_OF_THE_VALLEY(),
    LOOM(),
    MOJANG_BANNER_PATTERN(),
    MOSSY_COBBLESTONE_SLAB(CMIMC.SLAB),
    MOSSY_COBBLESTONE_STAIRS(CMIMC.STAIRS),
    MOSSY_STONE_BRICK_SLAB(CMIMC.SLAB),
    MOSSY_STONE_BRICK_STAIRS(CMIMC.STAIRS),
    MOSSY_STONE_BRICK_WALL(CMIMC.WALL),
    NETHER_BRICK_WALL(CMIMC.WALL),
    OAK_SIGN("Sign", CMIMC.SIGN),
    OAK_WALL_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    PANDA_SPAWN_EGG(CMIMC.SPAWNEGG),
    PILLAGER_SPAWN_EGG(CMIMC.SPAWNEGG),
    POLISHED_ANDESITE_STAIRS(CMIMC.STAIRS),
    POLISHED_ANDESITE_SLAB(CMIMC.SLAB),
    POLISHED_DIORITE_SLAB(CMIMC.SLAB),
    POLISHED_DIORITE_STAIRS(CMIMC.STAIRS),
    POLISHED_GRANITE_SLAB(CMIMC.SLAB),
    POLISHED_GRANITE_STAIRS(CMIMC.STAIRS),
    POTTED_BAMBOO(CMIMC.POTTED),
    POTTED_CORNFLOWER(CMIMC.POTTED),
    POTTED_LILY_OF_THE_VALLEY(CMIMC.POTTED),
    POTTED_WITHER_ROSE(CMIMC.POTTED),
    PRISMARINE_WALL(CMIMC.WALL),
    RAVAGER_SPAWN_EGG(CMIMC.SPAWNEGG),
    RED_DYE(CMIMC.DYE),
    RED_NETHER_BRICK_SLAB(CMIMC.SLAB),
    RED_NETHER_BRICK_STAIRS(CMIMC.STAIRS),
    RED_NETHER_BRICK_WALL(CMIMC.WALL),
    RED_SANDSTONE_WALL(CMIMC.WALL),
    SANDSTONE_WALL(CMIMC.WALL),
    SCAFFOLDING(),
    SKULL_BANNER_PATTERN(),
    SMITHING_TABLE(),
    SMOKER(),
    SMOOTH_QUARTZ_SLAB(CMIMC.SLAB),
    SMOOTH_QUARTZ_STAIRS(CMIMC.STAIRS),
    SMOOTH_RED_SANDSTONE_SLAB(CMIMC.SLAB),
    SMOOTH_RED_SANDSTONE_STAIRS(CMIMC.STAIRS),
    SMOOTH_SANDSTONE_SLAB(CMIMC.SLAB),
    SMOOTH_SANDSTONE_STAIRS(CMIMC.STAIRS),
    SMOOTH_STONE_SLAB(CMIMC.SLAB),
    SPRUCE_SIGN(CMIMC.SIGN),
    SPRUCE_WALL_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    STONECUTTER(),
    STONE_BRICK_WALL(CMIMC.WALL),
    STONE_STAIRS(CMIMC.STAIRS),
    SUSPICIOUS_STEW(),
    SWEET_BERRIES(),
    SWEET_BERRY_BUSH(),
    TRADER_LLAMA_SPAWN_EGG(CMIMC.SPAWNEGG),
    WANDERING_TRADER_SPAWN_EGG(CMIMC.SPAWNEGG),
    WHITE_DYE(CMIMC.DYE),
    WITHER_ROSE(),
    YELLOW_DYE(CMIMC.DYE),
    COMPOSTER(),

    //1.15    
    BEEHIVE(),
    BEE_NEST(),
    BEE_SPAWN_EGG(CMIMC.SPAWNEGG),
    HONEYCOMB(),
    HONEYCOMB_BLOCK(),
    HONEY_BLOCK(),
    HONEY_BOTTLE(),

    //1.16.1
    ANCIENT_DEBRIS(),
    BASALT(),
    BLACKSTONE(),
    BLACKSTONE_SLAB(CMIMC.SLAB),
    BLACKSTONE_STAIRS(CMIMC.STAIRS),
    BLACKSTONE_WALL(CMIMC.WALL),
    CHAIN(),
    CHISELED_NETHER_BRICKS(),
    CHISELED_POLISHED_BLACKSTONE(),
    CRACKED_NETHER_BRICKS(),
    CRACKED_POLISHED_BLACKSTONE_BRICKS(),
    CRIMSON_BUTTON(CMIMC.BUTTON),
    CRIMSON_DOOR(CMIMC.DOOR),
    CRIMSON_FENCE(CMIMC.SEETHROW, CMIMC.FENCE),
    CRIMSON_FENCE_GATE(CMIMC.SEETHROW, CMIMC.FENCEGATE),
    CRIMSON_FUNGUS(),
    CRIMSON_HYPHAE(),
    CRIMSON_NYLIUM(),
    CRIMSON_PLANKS(),
    CRIMSON_PRESSURE_PLATE(CMIMC.PRESSUREPLATE),
    CRIMSON_ROOTS(),
    CRIMSON_SIGN(CMIMC.SIGN),
    CRIMSON_WALL_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    CRIMSON_SLAB(CMIMC.SLAB),
    CRIMSON_STAIRS(CMIMC.STAIRS),
    CRIMSON_STEM(),
    CRIMSON_TRAPDOOR(CMIMC.TRAPDOOR),
    CRYING_OBSIDIAN(),
    GILDED_BLACKSTONE(),
    HOGLIN_SPAWN_EGG(CMIMC.SPAWNEGG),
    LODESTONE(),
    MUSIC_DISC_PIGSTEP(),
    NETHERITE_AXE(CMIMC.WEAPON, CMIMC.TOOL, CMIMC.AXE),
    NETHERITE_BLOCK("netherite"),
    NETHERITE_BOOTS(CMIMC.ARMOR, CMIMC.BOOTS),
    NETHERITE_CHESTPLATE(CMIMC.ARMOR, CMIMC.CHESTPLATE),
    NETHERITE_HELMET(CMIMC.ARMOR, CMIMC.HELMET),
    NETHERITE_HOE(CMIMC.TOOL, CMIMC.HOE),
    NETHERITE_INGOT(),
    NETHERITE_LEGGINGS(CMIMC.ARMOR, CMIMC.LEGGINGS),
    NETHERITE_PICKAXE(CMIMC.TOOL, CMIMC.PICKAXE),
    NETHERITE_SCRAP(),
    NETHERITE_SHOVEL(CMIMC.TOOL, CMIMC.SHOVEL),
    NETHERITE_SWORD(CMIMC.WEAPON),
    NETHER_GOLD_ORE(),
    NETHER_SPROUTS(),
    PIGLIN_BANNER_PATTERN(),
    PIGLIN_SPAWN_EGG(CMIMC.SPAWNEGG),
    POLISHED_BASALT(),
    POLISHED_BLACKSTONE(),
    POLISHED_BLACKSTONE_BRICKS(),
    POLISHED_BLACKSTONE_BRICK_SLAB(CMIMC.SLAB),
    POLISHED_BLACKSTONE_BRICK_STAIRS(CMIMC.STAIRS),
    POLISHED_BLACKSTONE_BRICK_WALL(CMIMC.WALL),
    POLISHED_BLACKSTONE_BUTTON(CMIMC.BUTTON),
    POLISHED_BLACKSTONE_PRESSURE_PLATE(CMIMC.PRESSUREPLATE),
    POLISHED_BLACKSTONE_SLAB(CMIMC.SLAB),
    POLISHED_BLACKSTONE_STAIRS(CMIMC.STAIRS),
    POLISHED_BLACKSTONE_WALL(CMIMC.WALL),
    POTTED_CRIMSON_FUNGUS(CMIMC.POTTED),
    POTTED_CRIMSON_ROOTS(CMIMC.POTTED),
    POTTED_WARPED_FUNGUS(CMIMC.POTTED),
    POTTED_WARPED_ROOTS(CMIMC.POTTED),
    QUARTZ_BRICKS(),
    RESPAWN_ANCHOR("Anchor"),
    SHROOMLIGHT(),
    SOUL_CAMPFIRE(),
    SOUL_FIRE(),
    SOUL_LANTERN(),
    SOUL_SOIL(),
    SOUL_TORCH(),
    SOUL_WALL_TORCH(),
    STRIDER_SPAWN_EGG(CMIMC.SPAWNEGG),
    STRIPPED_CRIMSON_HYPHAE(),
    STRIPPED_CRIMSON_STEM(),
    STRIPPED_WARPED_HYPHAE(),
    STRIPPED_WARPED_STEM(),
    TARGET(),
    TWISTING_VINES(),
    TWISTING_VINES_PLANT(),
    WARPED_BUTTON(CMIMC.BUTTON),
    WARPED_DOOR(CMIMC.DOOR),
    WARPED_FENCE(CMIMC.SEETHROW, CMIMC.FENCE),
    WARPED_FENCE_GATE(CMIMC.SEETHROW, CMIMC.FENCEGATE),
    WARPED_FUNGUS(),
    WARPED_FUNGUS_ON_A_STICK(),
    WARPED_HYPHAE(),
    WARPED_NYLIUM(),
    WARPED_PLANKS(),
    WARPED_PRESSURE_PLATE(CMIMC.PRESSUREPLATE),
    WARPED_ROOTS(),
    WARPED_SIGN(CMIMC.SIGN),
    WARPED_WALL_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    WARPED_SLAB(CMIMC.SLAB),
    WARPED_STAIRS(CMIMC.STAIRS),
    WARPED_STEM(),
    WARPED_TRAPDOOR(CMIMC.TRAPDOOR),
    WARPED_WART_BLOCK("Warped Wart"),
    WEEPING_VINES(),
    WEEPING_VINES_PLANT(),
    ZOGLIN_SPAWN_EGG(CMIMC.SPAWNEGG),
    ZOMBIFIED_PIGLIN_SPAWN_EGG(CMIMC.SPAWNEGG),

    // 1.16.2
    PIGLIN_BRUTE_SPAWN_EGG(CMIMC.SPAWNEGG),

    // 1.17.0
    AMETHYST_BLOCK(),
    AMETHYST_CLUSTER(),
    AMETHYST_SHARD(),
    AXOLOTL_BUCKET(CMIMC.BUCKETANIMAL),
    AXOLOTL_SPAWN_EGG(CMIMC.SPAWNEGG),
    AZALEA(),
    AZALEA_LEAVES(),
    BIG_DRIPLEAF(),
    BIG_DRIPLEAF_STEM(),
    BLACK_CANDLE(CMIMC.CANDLE),
    BLACK_CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),
    BLUE_CANDLE(CMIMC.CANDLE),
    BLUE_CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),
    BROWN_CANDLE(CMIMC.CANDLE),
    BROWN_CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),
    BUDDING_AMETHYST(),
    BUNDLE(),
    CALCITE(),
    CANDLE(CMIMC.CANDLE),
    CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),
    CAVE_VINES(),
    CAVE_VINES_PLANT(),
    CHISELED_DEEPSLATE(),
    COBBLED_DEEPSLATE(),
    COBBLED_DEEPSLATE_SLAB(CMIMC.SLAB),
    COBBLED_DEEPSLATE_STAIRS(CMIMC.STAIRS),
    COBBLED_DEEPSLATE_WALL(CMIMC.WALL),
    COPPER_BLOCK(CMIMC.COPPER),
    COPPER_INGOT(),
    COPPER_ORE(),
    CRACKED_DEEPSLATE_BRICKS(),
    CRACKED_DEEPSLATE_TILES(),
    CUT_COPPER(CMIMC.COPPER),
    CUT_COPPER_SLAB(CMIMC.SLAB, CMIMC.COPPER),
    CUT_COPPER_STAIRS(CMIMC.STAIRS, CMIMC.COPPER),
    CYAN_CANDLE(CMIMC.CANDLE),
    CYAN_CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),
    DEEPSLATE(),
    DEEPSLATE_BRICKS(),
    DEEPSLATE_BRICK_SLAB(CMIMC.SLAB),
    DEEPSLATE_BRICK_STAIRS(CMIMC.STAIRS),
    DEEPSLATE_BRICK_WALL(CMIMC.WALL),
    DEEPSLATE_COAL_ORE(),
    DEEPSLATE_COPPER_ORE(),
    DEEPSLATE_DIAMOND_ORE(),
    DEEPSLATE_EMERALD_ORE(),
    DEEPSLATE_GOLD_ORE(),
    DEEPSLATE_IRON_ORE(),
    DEEPSLATE_LAPIS_ORE(),
    DEEPSLATE_REDSTONE_ORE(),
    DEEPSLATE_TILES(),
    DEEPSLATE_TILE_SLAB(CMIMC.SLAB),
    DEEPSLATE_TILE_STAIRS(CMIMC.STAIRS),
    DEEPSLATE_TILE_WALL(CMIMC.WALL),
    // Grass_path Renamed To Dirt_path In 1.17
    DIRT_PATH("GRASS_PATH"),
    DRIPSTONE_BLOCK(),
    EXPOSED_COPPER(CMIMC.COPPER),
    EXPOSED_CUT_COPPER(CMIMC.COPPER),
    EXPOSED_CUT_COPPER_SLAB(CMIMC.SLAB, CMIMC.COPPER),
    EXPOSED_CUT_COPPER_STAIRS(CMIMC.STAIRS, CMIMC.COPPER),
    FLOWERING_AZALEA(),
    FLOWERING_AZALEA_LEAVES(),
    GLOW_BERRIES(),
    GLOW_INK_SAC(CMIMC.DYE),
    GLOW_ITEM_FRAME(),
    GLOW_LICHEN(),
    GLOW_SQUID_SPAWN_EGG(CMIMC.SPAWNEGG),
    GOAT_SPAWN_EGG(CMIMC.SPAWNEGG),
    GRAY_CANDLE(CMIMC.CANDLE),
    GRAY_CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),
    GREEN_CANDLE(CMIMC.CANDLE),
    GREEN_CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),
    HANGING_ROOTS(),
    INFESTED_DEEPSLATE(),
    LARGE_AMETHYST_BUD(),
    LAVA_CAULDRON(),
    LIGHT(),
    LIGHTNING_ROD(),
    LIGHT_BLUE_CANDLE(CMIMC.CANDLE),
    LIGHT_BLUE_CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),
    LIGHT_GRAY_CANDLE(CMIMC.CANDLE),
    LIGHT_GRAY_CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),
    LIME_CANDLE(CMIMC.CANDLE),
    LIME_CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),
    MAGENTA_CANDLE(CMIMC.CANDLE),
    MAGENTA_CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),
    MEDIUM_AMETHYST_BUD(),
    MOSS_BLOCK(),
    MOSS_CARPET(CMIMC.CARPET),
    ORANGE_CANDLE(CMIMC.CANDLE),
    ORANGE_CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),
    OXIDIZED_COPPER(CMIMC.COPPER),
    OXIDIZED_CUT_COPPER(CMIMC.COPPER),
    OXIDIZED_CUT_COPPER_SLAB(CMIMC.SLAB, CMIMC.COPPER),
    OXIDIZED_CUT_COPPER_STAIRS(CMIMC.STAIRS, CMIMC.COPPER),
    PINK_CANDLE(CMIMC.CANDLE),
    PINK_CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),
    POINTED_DRIPSTONE(),
    POLISHED_DEEPSLATE(),
    POLISHED_DEEPSLATE_SLAB(CMIMC.SLAB),
    POLISHED_DEEPSLATE_STAIRS(CMIMC.STAIRS),
    POLISHED_DEEPSLATE_WALL(CMIMC.WALL),
    POTTED_AZALEA_BUSH(CMIMC.POTTED),
    POTTED_FLOWERING_AZALEA_BUSH(CMIMC.POTTED),
    POWDER_SNOW(),
    POWDER_SNOW_BUCKET(),
    POWDER_SNOW_CAULDRON(),
    PURPLE_CANDLE(CMIMC.CANDLE),
    PURPLE_CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),
    RAW_COPPER(),
    RAW_COPPER_BLOCK(CMIMC.COPPER),
    RAW_GOLD(),
    RAW_GOLD_BLOCK(),
    RAW_IRON(),
    RAW_IRON_BLOCK(),
    RED_CANDLE(CMIMC.CANDLE),
    RED_CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),
    ROOTED_DIRT(),
    SCULK_SENSOR(),
    SMALL_AMETHYST_BUD(),
    SMALL_DRIPLEAF(),
    SMOOTH_BASALT(),
    SPORE_BLOSSOM(),
    SPYGLASS(),
    TINTED_GLASS(),
    TUFF(),
    WATER_CAULDRON(),
    WAXED_COPPER_BLOCK(CMIMC.COPPER, CMIMC.WAXED),
    WAXED_CUT_COPPER(CMIMC.COPPER, CMIMC.WAXED),
    WAXED_CUT_COPPER_SLAB(CMIMC.SLAB, CMIMC.COPPER, CMIMC.WAXED),
    WAXED_CUT_COPPER_STAIRS(CMIMC.STAIRS, CMIMC.COPPER, CMIMC.WAXED),
    WAXED_EXPOSED_COPPER(CMIMC.COPPER, CMIMC.WAXED),
    WAXED_EXPOSED_CUT_COPPER(CMIMC.COPPER, CMIMC.WAXED),
    WAXED_EXPOSED_CUT_COPPER_SLAB(CMIMC.SLAB, CMIMC.COPPER, CMIMC.WAXED),
    WAXED_EXPOSED_CUT_COPPER_STAIRS(CMIMC.STAIRS, CMIMC.COPPER, CMIMC.WAXED),
    WAXED_OXIDIZED_COPPER(CMIMC.COPPER, CMIMC.WAXED),
    WAXED_OXIDIZED_CUT_COPPER(CMIMC.COPPER, CMIMC.WAXED),
    WAXED_OXIDIZED_CUT_COPPER_SLAB(CMIMC.SLAB, CMIMC.COPPER, CMIMC.WAXED),
    WAXED_OXIDIZED_CUT_COPPER_STAIRS(CMIMC.STAIRS, CMIMC.COPPER, CMIMC.WAXED),
    WAXED_WEATHERED_COPPER(CMIMC.COPPER, CMIMC.WAXED),
    WAXED_WEATHERED_CUT_COPPER(CMIMC.COPPER, CMIMC.WAXED),
    WAXED_WEATHERED_CUT_COPPER_SLAB(CMIMC.SLAB, CMIMC.COPPER, CMIMC.WAXED),
    WAXED_WEATHERED_CUT_COPPER_STAIRS(CMIMC.STAIRS, CMIMC.COPPER, CMIMC.WAXED),
    WEATHERED_COPPER(CMIMC.COPPER, CMIMC.WAXED),
    WEATHERED_CUT_COPPER(CMIMC.COPPER, CMIMC.WAXED),
    WEATHERED_CUT_COPPER_SLAB(CMIMC.SLAB, CMIMC.COPPER, CMIMC.WAXED),
    WEATHERED_CUT_COPPER_STAIRS(CMIMC.STAIRS, CMIMC.COPPER, CMIMC.WAXED),
    WHITE_CANDLE(CMIMC.CANDLE),
    WHITE_CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),
    YELLOW_CANDLE(CMIMC.CANDLE),
    YELLOW_CANDLE_CAKE(CMIMC.CAKE, CMIMC.CANDLECAKE),

    // 1.18.0
    MUSIC_DISC_OTHERSIDE(),

    // 1.19.0
    ACACIA_CHEST_BOAT(CMIMC.BOAT, CMIMC.CHESTBOAT),
    ALLAY_SPAWN_EGG(CMIMC.SPAWNEGG),
    BIRCH_CHEST_BOAT(CMIMC.BOAT, CMIMC.CHESTBOAT),
    DARK_OAK_CHEST_BOAT(CMIMC.BOAT, CMIMC.CHESTBOAT),
    DISC_FRAGMENT_5(),
    ECHO_SHARD(),
    FROGSPAWN(),
    FROG_SPAWN_EGG(CMIMC.SPAWNEGG),
    GOAT_HORN(),
    JUNGLE_CHEST_BOAT(CMIMC.BOAT, CMIMC.CHESTBOAT),
    MANGROVE_BOAT(CMIMC.BOAT),
    MANGROVE_BUTTON(CMIMC.BUTTON),
    MANGROVE_CHEST_BOAT(CMIMC.BOAT, CMIMC.CHESTBOAT),
    MANGROVE_DOOR(CMIMC.DOOR),
    MANGROVE_FENCE(CMIMC.SEETHROW, CMIMC.FENCE),
    MANGROVE_FENCE_GATE(CMIMC.SEETHROW, CMIMC.FENCEGATE),
    MANGROVE_LEAVES(),
    MANGROVE_LOG(),
    MANGROVE_PLANKS(),
    MANGROVE_PRESSURE_PLATE(CMIMC.PRESSUREPLATE),
    MANGROVE_PROPAGULE(),
    MANGROVE_ROOTS(),
    MANGROVE_SIGN(CMIMC.SIGN),
    MANGROVE_WALL_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    MANGROVE_SLAB(CMIMC.SLAB),
    MANGROVE_STAIRS(CMIMC.STAIRS),
    MANGROVE_TRAPDOOR(CMIMC.TRAPDOOR),
    MANGROVE_WOOD(),
    MUD(),
    MUDDY_MANGROVE_ROOTS(),
    MUD_BRICKS(),
    MUD_BRICK_SLAB(CMIMC.SLAB),
    MUD_BRICK_STAIRS(CMIMC.STAIRS),
    MUD_BRICK_WALL(CMIMC.WALL),
    MUSIC_DISC_5(),
    OAK_CHEST_BOAT(CMIMC.BOAT, CMIMC.CHESTBOAT),
    OCHRE_FROGLIGHT(),
    PACKED_MUD(),
    PEARLESCENT_FROGLIGHT(),
    POTTED_MANGROVE_PROPAGULE(CMIMC.POTTED),
    RECOVERY_COMPASS(),
    REINFORCED_DEEPSLATE(),
    SCULK(),
    SCULK_CATALYST(),
    SCULK_SHRIEKER(),
    SCULK_VEIN(),
    SPRUCE_CHEST_BOAT(CMIMC.BOAT, CMIMC.CHESTBOAT),
    STRIPPED_MANGROVE_LOG(),
    STRIPPED_MANGROVE_WOOD(),
    TADPOLE_BUCKET(CMIMC.BUCKETANIMAL),
    TADPOLE_SPAWN_EGG(CMIMC.SPAWNEGG),
    VERDANT_FROGLIGHT(),
    WARDEN_SPAWN_EGG(CMIMC.SPAWNEGG),

    // 1.20
    ACACIA_HANGING_SIGN(CMIMC.SIGN),
    ACACIA_WALL_HANGING_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    ANGLER_POTTERY_SHERD(),
    ARCHER_POTTERY_SHERD(),
    ARMS_UP_POTTERY_SHERD(),
    BAMBOO_BLOCK(),
    BAMBOO_BUTTON(CMIMC.BUTTON),
    BAMBOO_CHEST_RAFT(CMIMC.BOAT, CMIMC.RAFT, CMIMC.CHESTBOAT),
    BAMBOO_DOOR(CMIMC.DOOR),
    BAMBOO_FENCE(CMIMC.SEETHROW, CMIMC.FENCE),
    BAMBOO_FENCE_GATE(CMIMC.SEETHROW, CMIMC.FENCEGATE),
    BAMBOO_HANGING_SIGN(CMIMC.SIGN),
    BAMBOO_MOSAIC(),
    BAMBOO_MOSAIC_SLAB(CMIMC.SLAB),
    BAMBOO_MOSAIC_STAIRS(CMIMC.STAIRS),
    BAMBOO_PLANKS(),
    BAMBOO_PRESSURE_PLATE(CMIMC.PRESSUREPLATE),
    BAMBOO_RAFT(CMIMC.BOAT, CMIMC.RAFT),
    BAMBOO_SIGN(CMIMC.SIGN),
    BAMBOO_SLAB(CMIMC.SLAB),
    BAMBOO_STAIRS(CMIMC.STAIRS),
    BAMBOO_TRAPDOOR(CMIMC.TRAPDOOR),
    BAMBOO_WALL_HANGING_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    BAMBOO_WALL_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    BIRCH_HANGING_SIGN(CMIMC.SIGN),
    BIRCH_WALL_HANGING_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    BLADE_POTTERY_SHERD(),
    BREWER_POTTERY_SHERD(),
    BRUSH(CMIMC.TOOL),
    BURN_POTTERY_SHERD(),
    CALIBRATED_SCULK_SENSOR(),
    CAMEL_SPAWN_EGG(CMIMC.SPAWNEGG),
    CHERRY_BOAT(CMIMC.BOAT),
    CHERRY_BUTTON(CMIMC.BUTTON),
    CHERRY_CHEST_BOAT(CMIMC.BOAT, CMIMC.CHESTBOAT),
    CHERRY_DOOR(CMIMC.DOOR),
    CHERRY_FENCE(CMIMC.SEETHROW, CMIMC.FENCE),
    CHERRY_FENCE_GATE(CMIMC.SEETHROW, CMIMC.FENCEGATE),
    CHERRY_HANGING_SIGN(CMIMC.SIGN),
    CHERRY_LEAVES(),
    CHERRY_LOG(),
    CHERRY_PLANKS(),
    CHERRY_PRESSURE_PLATE(CMIMC.PRESSUREPLATE),
    CHERRY_SAPLING(CMIMC.SAPLING),
    CHERRY_SIGN(CMIMC.SIGN),
    CHERRY_SLAB(CMIMC.SLAB),
    CHERRY_STAIRS(CMIMC.STAIRS),
    CHERRY_TRAPDOOR(CMIMC.TRAPDOOR),
    CHERRY_WALL_HANGING_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    CHERRY_WALL_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    CHERRY_WOOD(),
    CHISELED_BOOKSHELF(),
    COAST_ARMOR_TRIM_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    CRIMSON_HANGING_SIGN(CMIMC.SIGN),
    CRIMSON_WALL_HANGING_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    DANGER_POTTERY_SHERD(),
    DARK_OAK_HANGING_SIGN(CMIMC.SIGN),
    DARK_OAK_WALL_HANGING_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    DECORATED_POT(),
    DUNE_ARMOR_TRIM_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    ENDER_DRAGON_SPAWN_EGG(CMIMC.SPAWNEGG),
    EXPLORER_POTTERY_SHERD(),
    EYE_ARMOR_TRIM_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    FRIEND_POTTERY_SHERD(),
    HEARTBREAK_POTTERY_SHERD(),
    HEART_POTTERY_SHERD(),
    HOST_ARMOR_TRIM_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    HOWL_POTTERY_SHERD(),
    IRON_GOLEM_SPAWN_EGG(CMIMC.SPAWNEGG),
    JUNGLE_HANGING_SIGN(CMIMC.SIGN),
    JUNGLE_WALL_HANGING_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    MANGROVE_HANGING_SIGN(CMIMC.SIGN),
    MANGROVE_WALL_HANGING_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    MINER_POTTERY_SHERD(),
    MOURNER_POTTERY_SHERD(),
    MUSIC_DISC_RELIC(),
    NETHERITE_UPGRADE_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    OAK_HANGING_SIGN(CMIMC.SIGN),
    OAK_WALL_HANGING_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    PIGLIN_HEAD(CMIMC.MONSTERHEAD),
    PIGLIN_WALL_HEAD(CMIMC.MONSTERHEAD),
    PINK_PETALS(),
    PITCHER_CROP(),
    PITCHER_PLANT(),
    PITCHER_POD(),
    PLENTY_POTTERY_SHERD(),
    POTTED_CHERRY_SAPLING(CMIMC.POTTED),
    POTTED_TORCHFLOWER(CMIMC.POTTED),
    PRIZE_POTTERY_SHERD(),
    RAISER_ARMOR_TRIM_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    RIB_ARMOR_TRIM_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    SENTRY_ARMOR_TRIM_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    SHAPER_ARMOR_TRIM_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    SHEAF_POTTERY_SHERD(),
    SHELTER_POTTERY_SHERD(),
    SILENCE_ARMOR_TRIM_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    SKULL_POTTERY_SHERD(),
    SNIFFER_EGG(CMIMC.EGG),
    SNIFFER_SPAWN_EGG(CMIMC.SPAWNEGG),
    SNORT_POTTERY_SHERD(),
    SNOUT_ARMOR_TRIM_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    SNOW_GOLEM_SPAWN_EGG(CMIMC.SPAWNEGG),
    SPIRE_ARMOR_TRIM_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    SPRUCE_HANGING_SIGN(CMIMC.SIGN),
    SPRUCE_WALL_HANGING_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    STRIPPED_BAMBOO_BLOCK(),
    STRIPPED_CHERRY_LOG(),
    STRIPPED_CHERRY_WOOD(),
    SUSPICIOUS_GRAVEL(),
    SUSPICIOUS_SAND(),
    TIDE_ARMOR_TRIM_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    TORCHFLOWER(),
    TORCHFLOWER_CROP(),
    TORCHFLOWER_SEEDS(),
    VEX_ARMOR_TRIM_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    WARD_ARMOR_TRIM_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    WARPED_HANGING_SIGN(CMIMC.SIGN),
    WARPED_WALL_HANGING_SIGN(CMIMC.SIGN, CMIMC.WALLSIGN),
    WAYFINDER_ARMOR_TRIM_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    WILD_ARMOR_TRIM_SMITHING_TEMPLATE(CMIMC.TEMPLATE),
    WITHER_SPAWN_EGG(CMIMC.SPAWNEGG),

    // Legacy
    SIGN(323),

    LEGACY_STATIONARY_WATER(9, "Stationary Water"),
    LEGACY_STATIONARY_LAVA(11, "Stationary Lava"),
    LEGACY_BURNING_FURNACE(62, "Burning Furnace"),
    LEGACY_NETHER_WARTS(115, "Nether Warts"),
    LEGACY_IRON_DOOR_BLOCK(71, "Iron Door Block", CMIMC.DOOR),
    LEGACY_GLOWING_REDSTON_ORE(74, "Glowing Redstone Ore"),
    LEGACY_SUGAR_CANE_BLOCK(83, "Sugar Cane Block"),
    LEGACY_RAW_FISH(349, "Raw Fish"),
    LEGACY_SKULL(144, "Skull", CMIMC.PLAYERHEAD, CMIMC.SKULL),
    LEGACY_SIGN_POST(63, "Sign Post"),
    LEGACY_BED_BLOCK(26, "Bed Block", CMIMC.BED),
    LEGACY_REDSTONE_TORCH_OFF(75, "Redstone Torch Off"),
    LEGACY_REDSTONE_TORCH_ON(76, "Redstone Torch On"),
    LEGACY_CAKE_BLOCK(92, "Cake Block"),
    LEGACY_DIODE_BLOCK_OFF(93, "Diode Block Off"),
    LEGACY_DIODE_BLOCK_ON(94, "Diode Block On"),
    LEGACY_MELON_BLOCK(103, "Melon Block"),

//	LEGACY_CAULDRON(118, 0, null, "LEGACY_CAULDRON", ""),
//	LEGACY_REDSTONE_LAMP_ON(124, null, null, "LEGACY_REDSTONE_LAMP_ON", ""),
//	LEGACY_WOOD_DOUBLE_STEP(125, null, null, "LEGACY_WOOD_DOUBLE_STEP", ""),
//	LEGACY_FLOWER_POT(140, null, null, "LEGACY_FLOWER_POT", ""),
    LEGACY_REDSTONE_COMPARATOR_OFF(149, "Redstone Comparator Off"),
    LEGACY_REDSTONE_COMPARATOR_ON(150, "Redstone Comparator On"),
//	LEGACY_STANDING_BANNER(176, null, null, "LEGACY_STANDING_BANNER", ""),
//	LEGACY_WALL_BANNER(177, null, null, "LEGACY_WALL_BANNER", ""),
//	LEGACY_DAYLIGHT_DETECTOR_INVERTED(178, null, null, "LEGACY_DAYLIGHT_DETECTOR_INVERTED", ""),
//	LEGACY_DOUBLE_STONE_SLAB2(181, null, null, "LEGACY_DOUBLE_STONE_SLAB2", ""),
    LEGACY_WOODEN_DOOR_BLOCK(64, "Wooden Door Block", CMIMC.DOOR),
    LEGACY_SPRUCE_DOOR(193, "Spruce Door Block", CMIMC.DOOR),
    LEGACY_BIRCH_DOOR(194, "Birch Door Block", CMIMC.DOOR),
    LEGACY_JUNGLE_DOOR(195, "Jungle Door Block", CMIMC.DOOR),
    LEGACY_ACACIA_DOOR(196, "Acacia Door Block", CMIMC.DOOR),
    LEGACY_DARK_OAK_DOOR(197, "Dark Oak Door Block", CMIMC.DOOR),
    LEGACY_GLOWING_REDSTONE_ORE(74, "Glowing Redstone Ore"),
    LEGACY_BREWING_STAND(117, "Brewing Stand Block"),
//	LEGACY_PURPUR_DOUBLE_SLAB(204, null, null, "LEGACY_PURPUR_DOUBLE_SLAB", ""),
//	LEGACY_COMMAND_REPEATING(210, null, null, "LEGACY_COMMAND_REPEATING", ""),
//	LEGACY_COMMAND_CHAIN(211, null, null, "LEGACY_COMMAND_CHAIN", ""),
    LEGACY_WHEAT(59, "Wheat Block");

    private int legacyId = -1;
    private short legacyData = 0;
    private boolean legacy = false;
    private String name;
    private String translatedName = null;
    private List<String> legacyName;
    private String bukkitName;
    private String mojangName;
    private Set<CMIMC> criteria = new HashSet<>();

    Material mat;

    CMIMaterial(CMIMC... criteria) {
        this(-1, (byte) 0, null, Arrays.asList(criteria));
    }

    CMIMaterial(String legacyName, CMIMC... criteria) {
        this(-1, (byte) 0, null, Arrays.asList(criteria), legacyName);
    }

    @Deprecated
    CMIMaterial(int legacyId, String legacyName1, String legacyName2, CMIMC... criteria) {
        this(legacyId, (byte) 0, null, Arrays.asList(criteria), legacyName1, legacyName2);
    }

    @Deprecated
    CMIMaterial(int legacyId, String legacyName1, String legacyName2, String legacyName3, CMIMC... criteria) {
        this(legacyId, (byte) 0, null, Arrays.asList(criteria), legacyName1, legacyName2, legacyName3);
    }

    @Deprecated
    CMIMaterial(int legacyId, int legacyData, CMIMC... criteria) {
        this(legacyId, (byte) legacyData, null, Arrays.asList(criteria), "");
    }

    @Deprecated
    CMIMaterial(int legacyId, CMIMC... criteria) {
        this(legacyId, (byte) 0, null, Arrays.asList(criteria), "");
    }

    @Deprecated
    CMIMaterial(int legacyId, int legacyData, String legacyName, CMIMC... criteria) {
        this(legacyId, (byte) legacyData, null, Arrays.asList(criteria), legacyName);
    }

    @Deprecated
    CMIMaterial(int legacyId, String legacyName, CMIMC... criteria) {
        this(legacyId, (byte) 0, null, Arrays.asList(criteria), legacyName);
    }

    CMIMaterial(int legacyId, short legacyData, String name, List<CMIMC> criteria, String... legacyName) {

        this.legacyId = legacyId;
        this.legacyData = legacyData;
        this.name = name == null ? CMIText.everyFirstToUpperCase(this.toString()) : name;
        if (legacyName != null && legacyName.length > 0 && !legacyName[0].isEmpty()) {
            this.legacyName = Arrays.asList(legacyName);
        }

        if (criteria != null)
            this.criteria = new HashSet<>(criteria);

        if (this.toString().startsWith("LEGACY_")) {
            legacy = true;
        }
    }

    public String getName() {
        return name;
    }

    @Deprecated
    public Integer getLegacyId() {
        return legacyId;
    }

    @Deprecated
    public Integer getId() {
        if (Version.isCurrentEqualOrHigher(Version.v1_13_R1)) {
            return -1;
        }
        return getLegacyId();
    }

    public Material getMaterial() {
        return mat;
    }

    public void updateMaterial() {
        mat = null;
        if (Version.isCurrentEqualOrHigher(Version.v1_13_R1)) {
            if (mat == null) {
                for (Material one : Material.values()) {
                    if (!one.name().replace("_", "").equalsIgnoreCase(this.name().replace("_", "")))
                        continue;
                    mat = one;
                    break;
                }
            }
        } else {
            if (Version.isCurrentEqualOrLower(Version.v1_12_R1) && this.equals(CMIMaterial.PODZOL)) {
                mat = null;
                return;
            }
            if (Version.isCurrentEqualOrLower(Version.v1_13_R2)) {
                if (mat == null && this.getId() != null) {
                    for (Material one : Material.class.getEnumConstants()) {
                        if (one.getId() != this.getId())
                            continue;
                        mat = one;
                        break;
                    }
                }
            }
            if (mat == null) {
                for (Material one : Material.class.getEnumConstants()) {
                    if (!one.name().replace("LEGACY_", "").replace("_", "").equalsIgnoreCase(this.name().replace("_", "")))
                        continue;
                    mat = one;
                    break;
                }
            }
            if (mat == null) {
                for (Material one : Material.class.getEnumConstants()) {
                    if (!one.name().replace("LEGACY_", "").replace("_", "").equalsIgnoreCase(this.getName().replace(" ", "")))
                        continue;
                    mat = one;
                    break;
                }
            }
            if (mat == null && !this.getLegacyNames().isEmpty()) {
                main: for (Material one : Material.class.getEnumConstants()) {
                    for (String oneL : this.getLegacyNames()) {
                        if (!one.name().replace("LEGACY_", "").replace("_", "").equalsIgnoreCase(oneL.replace(" ", "").replace("_", "")))
                            continue main;
                    }
                    mat = one;
                    break;
                }
            }
        }
    }

    public ItemStack newItemStack() {
        return newItemStack(1);
    }

    public ItemStack newItemStack(int amount) {
//	if (mat == null) {
//	    updateMaterial();
//	}
        if (mat == null) {
            return new ItemStack(Material.STONE);
        }

        try {
            if (!mat.isItem())
                return new ItemStack(Material.STONE);
        } catch (Throwable e) {
        }

        if (Version.isCurrentEqualOrHigher(Version.v1_13_R1)) {
            ItemStack stack = new ItemStack(mat);
            stack.setAmount(amount);
            return stack;
        }
        ItemStack stack = new ItemStack(mat, 1, (short) this.getLegacyData());
        stack.setAmount(amount);
        return stack;
    }

    public CMIItemStack newCMIItemStack() {
        return newCMIItemStack(1);
    }

    public CMIItemStack newCMIItemStack(int amount) {
//	if (mat == null) {
//	    updateMaterial();
//	}
        if (mat == null) {
            return new CMIItemStack(CMIMaterial.STONE);
        }
        if (Version.isCurrentEqualOrHigher(Version.v1_13_R1)) {
            CMIItemStack stack = new CMIItemStack(mat);
            stack.setAmount(amount);
            return stack;
        }
        ItemStack stack = new ItemStack(mat, 1, (short) this.getLegacyData());

        stack.setAmount(amount);
        return new CMIItemStack(stack);
    }

    @Deprecated
    public short getData() {
        if (Version.isCurrentEqualOrHigher(Version.v1_13_R1)) {
            return 0;
        }
        return getLegacyData();
    }

    @Deprecated
    public short getLegacyData() {
        return legacyData;
    }

    public static CMIMaterial getRandom(CMIMaterial mat) {

        List<CMIMaterial> ls = new ArrayList<CMIMaterial>();

        for (CMIMaterial one : CMIMaterial.values()) {
            if (one.getLegacyId() == null)
                continue;
            if (one.getLegacyId() != mat.getLegacyId())
                continue;
            ls.add(one);
        }

        if (ls.isEmpty() || ls.size() == 1) {
            String part = mat.name;
            if (part.contains("_"))
                part = part.split("_")[part.split("[_]").length - 1];
            for (CMIMaterial one : CMIMaterial.values()) {
                if (!one.name().endsWith(part))
                    continue;
                ls.add(one);
            }
        }

        Collections.shuffle(ls);

        return ls.isEmpty() ? CMIMaterial.NONE : ls.get(0);
    }

    public CMIMaterial getByColorId(int id) {
        return getByColorId(this, id);
    }

    public static CMIMaterial getByColorId(CMIMaterial mat, int id) {
        if (mat == null)
            return CMIMaterial.NONE;
        for (CMIMaterial one : CMIMaterial.values()) {
            if (one.getLegacyId() == null)
                continue;
            if (one.getLegacyId() != mat.getLegacyId())
                continue;
            if (one.getLegacyData() == id)
                return one;
        }

        return mat;
    }

    public static CMIMaterial get(String id) {

        if (id == null)
            return CMIMaterial.NONE;
        Integer ids = null;
        Integer data = null;
        id = id.replaceAll("_| |minecraft:", "").toLowerCase();

        String[] split = id.split(":", 2);
        if (Version.isCurrentEqualOrLower(Version.v1_12_R1)) {
            if (split.length > 1) {

                try {
                    ids = Integer.parseInt(split[0]);
                    if (ids <= 0)
                        return CMIMaterial.NONE;
                    return get(ids, Integer.parseInt(split[1]));
                } catch (Exception ex) {
                }

                try {
                    data = Integer.parseInt(split[1]);
                    id = split[0];
                    CMIMaterial mat = ItemManager.byName.get(id + ":" + data);
                    if (mat != null) {
                        return mat;
                    }
                    CMIMaterial mat1 = ItemManager.byName.get(id);
                    if (mat1 != null && mat1.getLegacyId() > 0) {
                        mat = get(mat1.getLegacyId(), data);
                        if (mat != null) {
                            return mat;
                        }
                    }
                } catch (Exception ex) {
                }
            }
        }

        CMIMaterial mat = ItemManager.byName.get(id);

        if (mat != null) {
            return mat;
        }

        try {
            mat = ItemManager.byId.get(Integer.parseInt(id));
            if (mat != null) {
                return mat;
            }
        } catch (Exception ex) {
        }

        if (id.contains(":")) {
            mat = ItemManager.byName.get(id.split(":")[0]);
            if (mat != null) {
                return mat;
            }
        }

        return CMIMaterial.NONE;
    }

    public static CMIMaterial get(Material mat) {
        if (mat == null)
            return CMIMaterial.NONE;
        CMIMaterial m = ItemManager.byRealMaterial.get(mat);
        if (m != null)
            return m;
        return get(mat.toString());
    }

    @Deprecated
    public static CMIMaterial get(int id) {
        for (CMIMaterial one : CMIMaterial.values()) {
            if (one.getMaterial() != null && one.getId() == id) {
                return one;
            }
        }
        for (CMIMaterial one : CMIMaterial.values()) {
            if (one.getLegacyId() == id) {
                return one;
            }
        }
        return CMIMaterial.NONE;
    }

    public static CMIMaterial get(ItemStack item) {
        if (item == null)
            return CMIMaterial.NONE;
        CMIMaterial mat = null;
        if (Version.isCurrentEqualOrLower(Version.v1_13_R2)) {

            mat = Version.isCurrentEqualOrHigher(Version.v1_13_R1) ? get(item.getType()) : get(item.getType().getId(), item.getData().getData());
            if (mat == null) {
                mat = ItemManager.byName.get(item.getType().toString().toLowerCase().replace("_", ""));
            }
        } else {
            mat = ItemManager.byRealMaterial.get(item.getType());
        }

        return mat == null ? CMIMaterial.NONE : mat;
    }

    public static CMIMaterial get(Block block) {
        if (block == null)
            return CMIMaterial.NONE;

        try {
            if (Bukkit.getWorld(block.getWorld().getUID()) == null)
                return CMIMaterial.NONE;
        } catch (Throwable e) {
            e.printStackTrace();
        }

        if (Version.isCurrentEqualOrHigher(Version.v1_14_R1)) {
            CMIMaterial res = ItemManager.byRealMaterial.get(block.getType());
            return res == null ? CMIMaterial.NONE : res;
        }

        byte data = Version.isCurrentEqualOrLower(Version.v1_13_R1) ? block.getData() : 0;
        if (block.getState() instanceof Skull) {
            Skull skull = (Skull) block.getState();
            data = (byte) skull.getSkullType().ordinal();
        }

        CMIMaterial mat = null;

        if (Version.isCurrentEqualOrHigher(Version.v1_14_R1)) {
            mat = ItemManager.byRealMaterial.get(block.getType());
        }

        if (mat == null) {
            mat = ItemManager.byName.get(block.getType().toString().replace("_", "").toLowerCase());
        }

        if (mat == null && Version.isCurrentEqualOrLower(Version.v1_13_R2)) {
            mat = get(block.getType().getId(), Version.isCurrentEqualOrHigher(Version.v1_13_R1) ? 0 : data);
        }
        return mat == null ? CMIMaterial.NONE : mat;
    }

    @Deprecated
    public static CMIMaterial get(int id, int data) {
        CMIMaterial mat = ItemManager.byName.get(id + ":" + data);
        if (mat != null) {
            return mat;
        }
        mat = ItemManager.byId.get(id);
        return mat == null ? CMIMaterial.NONE : mat;
    }

    @Deprecated
    public static CMIMaterial getLegacy(int id) {
        CMIMaterial mat = ItemManager.byId.get(id);
        if (mat != null)
            return mat;
        return CMIMaterial.NONE;
    }

    public short getMaxDurability() {
        return this.getMaterial() == null ? 0 : this.getMaterial().getMaxDurability();
    }

    public boolean isBlock() {
        return getMaterial() != null && getMaterial().isBlock();
    }

    public boolean isEquipment() {
        return getMaxDurability() > 16;
    }

    public boolean isSolid() {
        return getMaterial() != null && getMaterial().isSolid();
    }

    public boolean isValidAsItemStack() {

        ItemStack item = newItemStack();
        if (item == null || getMaterial() == null)
            return false;

        try {
            if (!getMaterial().isItem())
                return false;
        } catch (Throwable e) {
        }

        return isValidItem();
    }

    public static boolean isHoe(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isHoe();
    }

    public boolean isHoe() {
        return this.containsCriteria(CMIMC.HOE);
    }

    @Deprecated
    public static boolean isMonsterEgg(Material mat) {
        return isSpawnEgg(mat);
    }

    @Deprecated
    public boolean isMonsterEgg() {
        return isSpawnEgg();
    }

    public static boolean isSpawnEgg(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isSpawnEgg();
    }

    public boolean isSpawnEgg() {
        return this.containsCriteria(CMIMC.SPAWNEGG);
    }

    public static boolean isEgg(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isEgg();
    }

    public boolean isEgg() {
        return this.containsCriteria(CMIMC.EGG);
    }

    public static boolean isCandle(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isCandle();
    }

    public boolean isCandle() {
        return this.containsCriteria(CMIMC.CANDLE);
    }

    public static boolean isCandleCake(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isCandleCake();
    }

    public boolean isCandleCake() {
        return this.containsCriteria(CMIMC.CANDLECAKE);
    }

    public static boolean isCake(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isCake();
    }

    public boolean isCake() {
        return isCandleCake() || this.containsCriteria(CMIMC.CAKE);
    }

    public static boolean isBuckedAnimal(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isBuckedAnimal();
    }

    public boolean isBuckedAnimal() {
        return this.containsCriteria(CMIMC.BUCKETANIMAL);
    }

    public static boolean isBed(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isBed();
    }

    public boolean isBed() {
        return this.containsCriteria(CMIMC.BED);
    }

    public static boolean isStairs(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isStairs();
    }

    public boolean isStairs() {
        return this.containsCriteria(CMIMC.STAIRS);
    }

    public static boolean isPotion(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isPotion();
    }

    public boolean isPotion() {
        return this.containsCriteria(CMIMC.POTION);
    }

    public static boolean isBoat(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isBoat();
    }

    public boolean isBoat() {
        return this.containsCriteria(CMIMC.BOAT);
    }

    public static boolean isChestBoat(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isChestBoat();
    }

    public boolean isChestBoat() {
        return this.containsCriteria(CMIMC.CHESTBOAT);
    }

    public static boolean isSapling(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isSapling();
    }

    public boolean isSapling() {
        return this.containsCriteria(CMIMC.SAPLING);
    }

    public static boolean isButton(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isButton();
    }

    public boolean isButton() {
        return this.containsCriteria(CMIMC.BUTTON);
    }

    public static boolean isWater(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isWater();
    }

    public boolean isWater() {
        return this.equals(CMIMaterial.WATER) || this.equals(CMIMaterial.LEGACY_STATIONARY_WATER);
    }

    public static boolean isLava(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isLava();
    }

    public boolean isLava() {
        return this.equals(CMIMaterial.LAVA) || this.equals(CMIMaterial.LEGACY_STATIONARY_LAVA);
    }

    public static boolean isPlate(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isPlate();
    }

    public boolean isPlate() {
        return this.containsCriteria(CMIMC.PRESSUREPLATE);
    }

    public static boolean isWool(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isWool();
    }

    public boolean isWool() {
        return this.containsCriteria(CMIMC.WOOL);
    }

    public static boolean isCarpet(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isCarpet();
    }

    public boolean isCarpet() {
        return this.containsCriteria(CMIMC.CARPET);
    }

    public static boolean isShulkerBox(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isShulkerBox();
    }

    public boolean isShulkerBox() {
        return this.containsCriteria(CMIMC.SHULKERBOX);
    }

    public static boolean isLeatherArmor(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isLeatherArmor();
    }

    public boolean isLeatherArmor() {
        return this.containsCriteria(CMIMC.LEATHER) && this.containsCriteria(CMIMC.ARMOR);
    }

    public static boolean isArmor(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isArmor();
    }

    public boolean isArmor() {
        return isHelmet() || isLeggings() || isChestplate() || isBoots() || isShield();
    }

    public static boolean isHelmet(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isHelmet();
    }

    public boolean isHelmet() {
        return this.containsCriteria(CMIMC.HELMET);
    }

    public static boolean isLeggings(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isLeggings();
    }

    public boolean isLeggings() {
        return this.containsCriteria(CMIMC.LEGGINGS);
    }

    public static boolean isChestplate(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isChestplate();
    }

    public boolean isChestplate() {
        return this.containsCriteria(CMIMC.CHESTPLATE);
    }

    public static boolean isBoots(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isBoots();
    }

    public boolean isBoots() {
        return this.containsCriteria(CMIMC.BOOTS);
    }

    public static boolean isShield(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isShield();
    }

    public boolean isShield() {
        return this.equals(CMIMaterial.SHIELD);
    }

    public static boolean isWeapon(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isWeapon();
    }

    public boolean isWeapon() {
        return this.containsCriteria(CMIMC.WEAPON);
    }

    public static boolean isTool(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isTool();
    }

    public boolean isTool() {
        return this.containsCriteria(CMIMC.TOOL);
    }

    public static boolean isPickaxe(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isPickaxe();
    }

    public boolean isPickaxe() {
        return this.containsCriteria(CMIMC.PICKAXE);
    }

    public static boolean isValidItem(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isValidItem();
    }

    public boolean isValidItem() {
        return !this.equals(CMIMaterial.NONE) && !this.isAir() && this.getMaterial() != null;
    }

    public static boolean isValidAsItemStack(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isValidItem();
    }

    public boolean isNone() {
        return this.equals(CMIMaterial.NONE);
    }

    public static boolean isAir(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isAir();
    }

    public boolean isAir() {
        return this.containsCriteria(CMIMC.AIR);
    }

    public static boolean isPotted(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isPotted();
    }

    public boolean isPotted() {
        return this.containsCriteria(CMIMC.POTTED);
    }

    public static boolean isTemplate(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isTemplate();
    }

    public boolean isTemplate() {
        return this.containsCriteria(CMIMC.TEMPLATE);
    }

    public static boolean isAnvil(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isAnvil();
    }

    public boolean isAnvil() {
        return this.containsCriteria(CMIMC.ANVIL);
    }

    public static boolean isDoor(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isDoor();
    }

    public boolean isDoor() {
        return this.containsCriteria(CMIMC.DOOR);
    }

    public static boolean isGate(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isGate();
    }

    public boolean isGate() {
        return this.containsCriteria(CMIMC.FENCEGATE);
    }

    public static boolean isFence(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isFence();
    }

    public boolean isFence() {
        return this.containsCriteria(CMIMC.FENCE);
    }

    public static boolean isRail(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isRail();
    }

    public boolean isRail() {
        return this.containsCriteria(CMIMC.RAIL);
    }

    public static boolean isGlassPane(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isGlassPane();
    }

    public boolean isGlassPane() {
        return this.containsCriteria(CMIMC.GLASSPANE);
    }

    public static boolean isWallSign(Material mat) {
        CMIMaterial m = get(mat);
        return m == null ? false : m.isWallSign();
    }

    public boolean isWallSign() {
        return this.containsCriteria(CMIMC.WALLSIGN);
    }

    public static boolean isSign(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isSign();
    }

    public boolean isSign() {
        return containsCriteria(CMIMC.SIGN);
    }

    public static boolean isWall(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isWall();
    }

    public boolean isWall() {
        return this.containsCriteria(CMIMC.WALL);
    }

    public static boolean isTrapDoor(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isTrapDoor();
    }

    public boolean isTrapDoor() {
        return this.containsCriteria(CMIMC.TRAPDOOR);
    }

    public static boolean isSkull(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isSkull();
    }

    public boolean isSkull() {
        return isMonsterHead() || isPlayerHead();
    }

    public static boolean isMonsterHead(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isMonsterHead();
    }

    public boolean isMonsterHead() {
        return this.containsCriteria(CMIMC.SKULL) || this.containsCriteria(CMIMC.MONSTERHEAD);
    }

    public static boolean isPlayerHead(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isPlayerHead();
    }

    public boolean isPlayerHead() {
        return this.containsCriteria(CMIMC.PLAYERHEAD);
    }

    public static boolean isDye(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isDye();
    }

    public boolean isDye() {
        return this.containsCriteria(CMIMC.DYE);
    }

    public static boolean isSlab(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isSlab();
    }

    public boolean isSlab() {
        return this.containsCriteria(CMIMC.SLAB);
    }

    public static boolean isCopperBlock(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isCopperBlock();
    }

    public boolean isCopperBlock() {
        return this.containsCriteria(CMIMC.COPPER);
    }

    public static boolean isWaxedCopper(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isWaxedCopper();
    }

    public boolean isWaxedCopper() {
        return isCopperBlock() && this.containsCriteria(CMIMC.WAXED);
    }

    public static int getCopperStage(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? 0 : m.getCopperStage();
    }

    public int getCopperStage() {
        if (!this.toString().contains("COPPER"))
            return 0;
        switch (this) {
        case COPPER_BLOCK:
        case CUT_COPPER:
        case CUT_COPPER_SLAB:
        case CUT_COPPER_STAIRS:
        case WAXED_COPPER_BLOCK:
        case WAXED_CUT_COPPER:
        case WAXED_CUT_COPPER_SLAB:
        case WAXED_CUT_COPPER_STAIRS:
            return 1;
        case EXPOSED_COPPER:
        case EXPOSED_CUT_COPPER:
        case EXPOSED_CUT_COPPER_SLAB:
        case EXPOSED_CUT_COPPER_STAIRS:
        case WAXED_EXPOSED_COPPER:
        case WAXED_EXPOSED_CUT_COPPER:
        case WAXED_EXPOSED_CUT_COPPER_SLAB:
        case WAXED_EXPOSED_CUT_COPPER_STAIRS:
            return 2;
        case WEATHERED_COPPER:
        case WEATHERED_CUT_COPPER:
        case WEATHERED_CUT_COPPER_SLAB:
        case WEATHERED_CUT_COPPER_STAIRS:
        case WAXED_WEATHERED_COPPER:
        case WAXED_WEATHERED_CUT_COPPER:
        case WAXED_WEATHERED_CUT_COPPER_SLAB:
        case WAXED_WEATHERED_CUT_COPPER_STAIRS:
            return 3;
        case OXIDIZED_COPPER:
        case OXIDIZED_CUT_COPPER:
        case OXIDIZED_CUT_COPPER_SLAB:
        case OXIDIZED_CUT_COPPER_STAIRS:
        case WAXED_OXIDIZED_COPPER:
        case WAXED_OXIDIZED_CUT_COPPER:
        case WAXED_OXIDIZED_CUT_COPPER_SLAB:
        case WAXED_OXIDIZED_CUT_COPPER_STAIRS:
            return 4;
        default:
            break;
        }
        return 0;
    }

    public static boolean isDoublePlant(Material mat) {
        CMIMaterial m = CMIMaterial.get(mat);
        return m == null ? false : m.isDoublePlant();
    }

    public boolean isDoublePlant() {
        return this.containsCriteria(CMIMC.DOUBLEPLANT);
    }

    public static SlabType getSlabType(Block block) {
        if (!isSlab(block.getType()))
            return SlabType.NOTSLAB;

        if (Version.isCurrentEqualOrHigher(Version.v1_13_R1)) {
            if (block.getBlockData() instanceof org.bukkit.block.data.type.Slab) {
                org.bukkit.block.data.type.Slab slab = (org.bukkit.block.data.type.Slab) block.getBlockData();
                switch (slab.getType().toString()) {
                case "TOP":
                    return SlabType.TOP;
                case "BOTTOM":
                    return SlabType.BOTTOM;
                case "DOUBLE":
                    return SlabType.DOUBLE;
                }

            }
            return SlabType.NOTSLAB;
        }
        if (block.getType().name().contains("STEP")) {
            switch (CMIMaterial.get(block).getLegacyId()) {
            case 44:
                switch (block.getData()) {
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                case 6:
                case 7:
                    return SlabType.BOTTOM;
                default:
                    return SlabType.DOUBLE;
                }
            case 126:
                switch (block.getData()) {
                case 0:
                case 1:
                case 2:
                case 3:
                case 4:
                case 5:
                    return SlabType.BOTTOM;
                default:
                    return SlabType.DOUBLE;
                }
            case 182:
                switch (block.getData()) {
                case 0:
                    return SlabType.BOTTOM;
                default:
                    return SlabType.DOUBLE;
                }
            case 205:
                switch (block.getData()) {
                case 0:
                    return SlabType.BOTTOM;
                default:
                    return SlabType.DOUBLE;
                }
            }
        }

        return SlabType.NOTSLAB;
    }

    public boolean isCanHavePotionType() {
        return isPotion() || this == CMIMaterial.TIPPED_ARROW;
    }

    public static final Pattern STRIPPED_REPLACE = Pattern.compile("_[^_]+");
    public static final Pattern DARK_LIGHT_MATCH = Pattern.compile("^(DARK|LIGHT).+");
    public static final Pattern DARK_LIGHT_REPLACE = Pattern.compile(".+?_.+?_");
    public static final Pattern WOOD_MATCH = Pattern.compile("^(WHITE|ORANGE|MAGENTA|YELLOW|LIME|PINK|GRAY|CYAN|PURPLE|BLUE|BROWN|GREEN|RED|BLACK|OAK|SPRUCE|BIRCH|JUNGLE|ACACIA).+");
    public static final Pattern WOOD_REPLACE = Pattern.compile(".+?_");
    public static final Pattern COLOR_MATCH = Pattern.compile("(?i)^(WHITE|ORANGE|MAGENTA|YELLOW|LIME|PINK|GRAY|CYAN|PURPLE|BLUE|BROWN|GREEN|RED|BLACK|LIGHT_GRAY|LIGHT_BLUE)$");

    public static String getGeneralMaterialName(String fullName) {

        String newName = fullName.toUpperCase();
        if (newName.startsWith("STRIPPED")) {
            return STRIPPED_REPLACE.matcher(newName).replaceFirst("");
        }

        if (DARK_LIGHT_MATCH.matcher(newName).matches()) {
            return DARK_LIGHT_REPLACE.matcher(newName).replaceFirst("");
        }

        if (WOOD_MATCH.matcher(newName).matches()) {
            return WOOD_REPLACE.matcher(newName).replaceFirst("");
        }

        if (COLOR_MATCH.matcher(newName).matches()) {
            return "color";
        }

        return fullName;
    }

    @Deprecated
    public static byte getBlockData(Block block) {
        return getBlockAge(block);
    }

    public static byte getBlockAge(Block block) {
        if (Version.isCurrentEqualOrHigher(Version.v1_13_R1)) {
            if (block.getState().getBlockData() instanceof org.bukkit.block.data.Ageable) {
                org.bukkit.block.data.Ageable age = (org.bukkit.block.data.Ageable) block.getState().getBlockData();
                return (byte) age.getAge();
            }
            return 0;
        }

        byte data = block.getData();
        if (block.getType() == CMIMaterial.COCOA.getMaterial())
            switch (data) {
            case 0:
            case 1:
            case 2:
            case 3:
                data = 0;
                break;
            case 4:
            case 5:
            case 6:
            case 7:
                data = 1;
                break;
            case 8:
            case 9:
            case 10:
            case 11:
                data = 2;
                break;
            default:
                break;
            }
        return data;
    }

    public boolean equals(Material mat) {
        if (getMaterial() == null) {
            return false;
        }
        return this.getMaterial().equals(mat);
    }

    public List<String> getLegacyNames() {
        if (legacyName == null)
            legacyName = new ArrayList<String>();
        return legacyName;
    }

    public void addLegacyName(String legacyName) {
        if (legacyName == null)
            this.legacyName = new ArrayList<String>();
        this.legacyName.add(legacyName);
    }

    public String getBukkitName() {
        if (bukkitName == null)
            bukkitName = getMaterial() == null ? "N/A" : getMaterial().name();
        return bukkitName;
    }

    public void setBukkitName(String bukkitName) {
        this.bukkitName = bukkitName;
    }

    public String getMojangName() {
        if (mojangName == null)
            mojangName = CMILib.getInstance().getReflectionManager().getItemMinecraftName(this.newItemStack());
        return mojangName;
    }

    public void setMojangName(String mojangName) {
        this.mojangName = mojangName;
    }

    public Set<CMIMC> getCriteria() {
        return criteria;
    }

    public boolean containsCriteria(CMIMC criteria) {
        return this.criteria.contains(criteria);
    }

    public boolean isLegacy() {
        return legacy;
    }

    public String getTranslatedName() {
        return translatedName != null ? translatedName : this.getName();
    }

    public void setTranslatedName(String translatedName) {
        this.translatedName = translatedName;
    }
}
